public static HapticSequence ClickStorm() { HapticSequence seq = new HapticSequence(); HapticEffect eff = new HapticEffect(Effect.Double_Click, .0f); seq.AddEffect(0, eff); eff = new HapticEffect(Effect.Click, .0f); seq.AddEffect(0.1, eff); eff = new HapticEffect(Effect.Click, .0f); seq.AddEffect(0.2, eff); eff = new HapticEffect(Effect.Double_Click, .0f); seq.AddEffect(0.3, eff); eff = new HapticEffect(Effect.Triple_Click, .0f); seq.AddEffect(0.4, eff); eff = new HapticEffect(Effect.Double_Click, .0f); seq.AddEffect(0.5, eff); eff = new HapticEffect(Effect.Click, .0f); seq.AddEffect(0.6, eff); eff = new HapticEffect(Effect.Triple_Click, .0f); seq.AddEffect(0.7, eff); return(seq); }
public void SetTriggerSequence(HapticSequence sequence, string labelName) { LastSequence = sequence; greenBox.SetSequence(sequence); LastSequenceName = labelName; //Debug.Log("Set Last Sequence! \t" + (LastSequence != null) + "\n"); }
IEnumerator StomacheRumble() { gulpSource.volume = .85f; List <AreaFlag> locs = new List <AreaFlag>(); locs.Add(AreaFlag.Lower_Ab_Left); locs.Add(AreaFlag.Lower_Ab_Right); locs.Add(AreaFlag.Mid_Ab_Left); locs.Add(AreaFlag.Mid_Ab_Right); while (true) { AreaFlag loc = locs[Random.Range(0, locs.Count)]; string file = Random.Range(0, 1.0f) > .8f ? "Haptics/StomachRumbleHeavy" : "Haptics/StomachRumble"; HapticSequence seq = new HapticSequence(); seq.LoadFromAsset(file); seq.CreateHandle(loc).Play(); float waitDur = Random.Range(.05f, .15f); yield return(new WaitForSeconds(waitDur)); } }
/// <summary> /// A VERY random effect. More just for showing haptic varion /// </summary> /// <param name="randSeed"></param> /// <returns></returns> public static HapticSequence VeryRandomEffect(int randSeed) { //Debug.Log(randSeed + "\n"); System.Random rand = new System.Random(randSeed); HapticSequence seq = new HapticSequence(); int effIndex = rand.Next(0, SuitImpulseDemo.effectOptions.Length); float dur = ((float)rand.Next(0, 6)) / 3; float delay = 0; float offset = 0; HapticEffect eff = null; int HowManyEffects = rand.Next(2, 11); //Debug.Log("How many effects: " + HowManyEffects + "\n"); for (int i = 0; i < HowManyEffects; i++) { effIndex = rand.Next(0, SuitImpulseDemo.effectOptions.Length); dur = ((float)rand.Next(0, 6)) / 3; delay = ((float)rand.Next(0, 8)) / 20; eff = new HapticEffect(SuitImpulseDemo.effectOptions[effIndex], dur); seq.AddEffect(offset + delay, ((float)rand.Next(0, 10)) / 10, eff); offset = dur; } return(seq); }
private HapticHandle CreateHandle(SideOfHaptic side) { HapticHandle handle = null; if (TypeOfPlayable == PlayableType.Sequence) { HapticSequence seq = new HapticSequence(); seq.LoadFromAsset(PlayableResourceName); var areaFlag = side == SideOfHaptic.Left ? Where.Mirror() : Where; handle = seq.CreateHandle(areaFlag); } else if (TypeOfPlayable == PlayableType.Pattern) { HapticPattern pat = new HapticPattern(); pat.LoadFromAsset(PlayableResourceName); handle = pat.CreateHandle(); } else if (TypeOfPlayable == PlayableType.Experience) { HapticExperience exp = new HapticExperience(); exp.LoadFromAsset(PlayableResourceName); handle = exp.CreateHandle(); } else if (TypeOfPlayable == PlayableType.Impulse) { return(CreateImpulseHandle(side)); } return(handle); }
/// <summary> /// Creating a randomized code sequence is totally doable. /// This is a less than ideal approach (because static method) /// In your code you shouldn't use a static method like this (Do as I say, not as I do) /// </summary> /// <param name="randSeed">Hand in a random seed (or better yet, don't use random in static functions</param> /// <returns>A HapticSequence reference for use in Impulses</returns> public static HapticSequence RandomPulses(int randSeed) { //Debug.Log(randSeed + "\n"); System.Random rand = new System.Random(randSeed); HapticSequence seq = new HapticSequence(); float dur = ((float)rand.Next(0, 15)) / 10; float delay = ((float)rand.Next(0, 10)) / 20; HapticEffect eff = new HapticEffect(Effect.Pulse, dur); seq.AddEffect(0.0, ((float)rand.Next(0, 10)) / 10, eff); float offset = dur; dur = ((float)rand.Next(0, 15)) / 20; delay = ((float)rand.Next(0, 8)) / 20; //Debug.Log(dur + "\n"); eff = new HapticEffect(Effect.Pulse, dur); seq.AddEffect(offset + delay, ((float)rand.Next(0, 10)) / 10, eff); offset = dur; dur = ((float)rand.Next(0, 15)) / 20; delay = ((float)rand.Next(0, 8)) / 20; //Debug.Log(dur + "\n"); eff = new HapticEffect(Effect.Pulse, dur); seq.AddEffect(offset + delay, ((float)rand.Next(0, 10)) / 10, eff); return(seq); }
private HapticHandle CreateImpulseHandle(SideOfHaptic side) { if (TypeOfImpulse == ImpulseType.None) { return(null); } else if (TypeOfImpulse == ImpulseType.Emanation) { bool mirror = side == SideOfHaptic.Left; var impulse = ImpulseGenerator.BeginEmanatingEffect(mirror ? StartLocation.Mirror() : StartLocation, depth); HapticSequence seq = new HapticSequence(); seq.LoadFromAsset(HapticSequence); impulse.WithEffect(seq).WithAttenuation(attenuationPercentage).WithDuration(Duration); return(impulse.Play()); } else if (TypeOfImpulse == ImpulseType.Traversal) { bool mirror = side == SideOfHaptic.Left; var impulse = ImpulseGenerator.BeginTraversingImpulse( mirror ? StartLocation.Mirror() : StartLocation, mirror ? EndLocation.Mirror() : EndLocation); HapticSequence seq = new HapticSequence(); seq.LoadFromAsset(HapticSequence); impulse.WithEffect(seq).WithAttenuation(attenuationPercentage).WithDuration(Duration); return(impulse.Play()); } return(null); }
/// <summary> /// Create a HapticPattern from a HapticDefinitionFile /// </summary> /// <param name="key">Name of the root effect</param> /// <param name="hdf">A HapticDefinitionFile containing the root effect</param> /// <returns></returns> public static HapticPattern CreatePatternFromHDF(string key, HapticDefinitionFile hdf) { string cleanedKey = HapticResources.CleanName(key); if (LoadedPatterns.ContainsKey(cleanedKey)) { //Debug.Log("Pattern: " + cleanedKey + " already exists, returning it instead of needless reconstruction\n"); return(LoadedPatterns[cleanedKey].Pattern); } HapticPattern pat = ScriptableObject.CreateInstance <HapticPattern>(); var pattern_def_array = hdf.pattern_definitions[key]; foreach (var element in pattern_def_array) { //Debug.Log("Pattern Def Array: " + key + " " + element.sequence + "\n"); HapticSequence thisSeq = CreateSequenceFromHDF(element.sequence, hdf); thisSeq.name = element.sequence; ParameterizedSequence paraSeq = new ParameterizedSequence(thisSeq, element.ParseAreaFlag(), element.time, element.strength); pat.AddSequence(paraSeq); } EnsurePatternIsRemembered(cleanedKey, pat); return(pat); }
/// <summary> /// [Helper function] Looks for a haptic sequence File - "Resources/Haptics/" + filename /// Identical to making a new HapticSequence and calling it's LoadFromAsset("Haptics/" + filename) function /// </summary> /// <param name="sequenceFile"></param> /// <returns></returns> public HapticSequence GetSequence(string sequenceFile) { HapticSequence seq = new HapticSequence(); seq.LoadFromAsset("Haptics/" + sequenceFile); return(seq); }
/// <summary> /// Attempts to create a haptic sequence from the provided json path /// It will create a HDF and then turn the hdf into a HapticSequence. /// </summary> /// <param name="jsonPath">Ex: StreamingAssets/Haptics/NS Demos/sequences/click.sequence</param> public static HapticSequence CreateSequence(string jsonPath) { var fileName = Path.GetFileNameWithoutExtension(jsonPath); ////If we don't replace . with _, then Unity has serious trouble locating the file HapticSequence seq = null; bool isSeq = IsSequence(jsonPath); bool isPat = IsPattern(jsonPath); bool isExp = IsExperience(jsonPath); //Debug.Log("Attemtping haptic asset import: " + jsonPath + " " + isSeq + "\n" + fileName + "\n\n" + "\n"); if (isSeq) { seq = LoadSequenceFromJson(jsonPath); seq.name = CleanName(fileName); } else if (isPat) { Debug.LogError("Attempted to run a HapticResources.CreatePattern while providing a pattern at path: " + jsonPath + "\n\t"); } else if (isExp) { Debug.LogError("Attempted to run a HapticResources.CreateSequence while providing a experience at path: " + jsonPath + "\n\t"); } return(seq); }
void Start() { seq = new HapticSequence(); //By using a double click we can distinctly hear the difference. seq.LoadFromAsset("Haptics/double_click"); //Play it on load to make sure it loaded. seq.Play(AreaFlag.All_Areas); }
public static void EnsureSequenceIsRemembered(string key, HapticSequence sequence) { key = HapticResources.CleanName(key); if (!LoadedSequences.ContainsKey(key) && sequence != null) { LoadedSequences.Add(key, new SequenceImportData(sequence, key)); } }
void Thing() { HapticSequence seq = new HapticSequence(); //seq.Play(AreaFlag. //We want an AreaFlag like object. //It needs to be enum-like or classlike in behavior? }
/// <summary> /// Sets and overwrites this Impulse's current Sequence /// </summary> /// <param name="seq"></param> /// <returns></returns> public Impulse WithEffect(HapticSequence seq) { if (seq == null) { throw new ArgumentException("Attempted to assign a null HapticSequence seq - retaining previous HapticSequence", "seq"); } this.seq = seq; return(this); }
public static HapticSequence ClickHum() { HapticSequence seq = new HapticSequence(); HapticEffect eff = new HapticEffect(Effect.Click, 0.0f); seq.AddEffect(0, eff); eff = new HapticEffect(Effect.Hum, .2f); seq.AddEffect(.15, 0.5f, eff); return(seq); }
public static HapticSequence ThockClunk() { HapticSequence seq = new HapticSequence(); HapticEffect eff = new HapticEffect(Effect.Click, 0.15f); seq.AddEffect(0, eff); eff = new HapticEffect(Effect.Fuzz, .2f); seq.AddEffect(.15, eff); return(seq); }
public void CollideWithBody(HardlightSuit body, Collider col, Vector3 where) { //Default sequence, gets reassigned HapticSequence seq = body.GetSequence("pulse"); //Depending on the type of projectile that we are. switch (typeOfCollision) { case CollisionType.MinorCoinHit: //Hit the body with a simple effect name - which should be in "Resources/Haptics/<Name>" body.HitNearest(lastPosition, "click"); break; case CollisionType.SharpImpact: body.FindNearbyLocation(lastPosition); body.HitImpulse(lastPosition, body.GetSequence("pain_short"), .1f, 1, 0); //body.HitImpulse(lastPosition, Effect.Pulse, .2f, .35f, 1, 2); break; case CollisionType.ThudImpact: //This plays an effect across all found pads within a range. body.HitNearby(lastPosition, "click", BigImpactArea); break; case CollisionType.MediumCashPackHit: body.HitNearest(lastPosition, "pulse"); break; case CollisionType.SackOfGoldhit: //More helper function usage. This asset is from the Death and Dying pack (which is a very intense effect) seq = body.GetSequence("pain_short"); //This makes use of the other HitImpulse which allows for repeated effects. body.HitImpulse(lastPosition, seq, .2f, 2, 3, .15f, 1.0f); break; case CollisionType.MudBlob: seq = body.GetSequence("pulse"); body.HitImpulse(lastPosition, seq, .02f, 5, 3, .15f, 1.0f); break; } }
/// <summary> /// Plays the sequence on the single nearest HapticLocation /// Note: A HapticLocation can have an AreaFlag with multiple pads selected. /// </summary> /// <param name="point">A point in world space to compare</param> /// <param name="sequence">The sequence to play on the nearest location</param> /// <param name="maxDistance">The max distance the point can be from any HapticLocations</param> public AreaFlag HitNearest(Vector3 point, HapticSequence sequence, float maxDistance = 5.0f) { AreaFlag Where = FindNearestFlag(point, maxDistance); if (Where != AreaFlag.None) { sequence.CreateHandle(Where).Play(); } else { Debug.Log("Projectile hit the HardlightSuit but found no objects hit. Perhaps the maxDistance (" + maxDistance + ") is too small?\n\tOr the suit/prefab wasn't configured correctly.\n"); } return(Where); }
void Start() { if (hapticFilesToPlay == null) { hapticFilesToPlay = new string[0]; } sequences = new HapticSequence[hapticFilesToPlay.Length]; for (int i = 0; i < hapticFilesToPlay.Length; i++) { HapticSequence seq = new HapticSequence(); seq.LoadFromAsset(hapticFilesToPlay[i]); sequences[i] = seq; } }
public static HapticSequence DoubleClickImpact() { HapticSequence seq = new HapticSequence(); HapticEffect eff = new HapticEffect(Effect.Double_Click, 0.00f); seq.AddEffect(0, eff); eff = new HapticEffect(Effect.Buzz, .05f); seq.AddEffect(.05, eff); eff = new HapticEffect(Effect.Buzz, .10f); seq.AddEffect(.10, 0.6f, eff); eff = new HapticEffect(Effect.Buzz, .15f); seq.AddEffect(.2, 0.2f, eff); return(seq); }
/// <summary> /// Plays the sequence on all HapticLocations within a certain radius of the provided point. /// </summary> /// <param name="point">A point in world space to compare</param> /// <param name="sequence">The sequence to play on the nearby locations</param> /// <param name="impactRadius">The body is about .6 wide, .72 tall and .25 deep</param> public AreaFlag HitNearby(Vector3 point, HapticSequence sequence, float impactRadius = .35f) { AreaFlag Where = FindAllFlagsWithinRange(point, impactRadius, true); if (Where != AreaFlag.None) { sequence.CreateHandle(Where).Play(); } else { Debug.Log("Projectile hit the HardlightSuit but found no objects hit. Perhaps the impactRadius (" + impactRadius + ") is too small?\n\tOr the suit/prefab wasn't configured correctly.\n"); } return(Where); }
//todo: reimplement all these as assets public static HapticSequence ClickHumDoubleClick() { HapticSequence seq = new HapticSequence(); HapticEffect eff = new HapticEffect(Effect.Click); seq.AddEffect(0, eff); // eff = new HapticEffect("transition_hum", .50f, 1.0f); seq.AddEffect(0.10, eff); eff = new HapticEffect(Effect.Double_Click); seq.AddEffect(0.6, eff); return(seq); }
public static HapticSequence PulseBumpPulse() { HapticSequence seq = new HapticSequence(); HapticEffect eff = new HapticEffect(Effect.Pulse, 0.40f); seq.AddEffect(0.0, 0.7f, eff); eff = new HapticEffect(Effect.Bump, .0f); seq.AddEffect(0.40, eff); eff = new HapticEffect(Effect.Pulse, 0.0f); seq.AddEffect(0.55, 0.2f, eff); return(seq); }
internal static HapticSequence LoadSequenceFromJson(string jsonPath) { HapticDefinitionFile hdf = LoadHDFFromJson(jsonPath); if (hdf.root_effect.type == "sequence") { var seq = CodeHapticFactory.CreateSequenceFromHDF(hdf.root_effect.name, hdf); return(seq); } else { Debug.LogError("Error in LoadSequenceFromJson - likely an invalid path was provided\n\t" + hdf.root_effect.name + " is of type " + hdf.root_effect.type + "\n"); return(HapticSequence.CreateNew()); //throw new InvalidOperationException("Unable to load " + hdf.root_effect.name + " as a HapticSequence because it is a " + hdf.root_effect.type); } }
public static HapticSequence TripleClickFuzzFalloff() { HapticSequence seq = new HapticSequence(); HapticEffect eff = new HapticEffect(Effect.Triple_Click, 0.20f); seq.AddEffect(0.0, 0.7f, eff); eff = new HapticEffect(Effect.Fuzz, .20f); seq.AddEffect(0.2, eff); eff = new HapticEffect(Effect.Fuzz, .20f); seq.AddEffect(0.4, 0.5f, eff); return(seq); }
void Update() { //IF we should shock and we aren't currently if (ShouldShock && !CurrentlyShocking) { //Start the coroutine! StartCoroutine(ShockPlayer()); ShouldShock = false; } if (Input.GetKeyDown(KeyCode.G)) { HapticSequence seq = new HapticSequence(); seq.LoadFromAsset("Haptics/pulse"); seq.Play(AreaFlag.Left_All); } }
void Update() { bool moving = false; float velVal = 350; #region Direction Controls if (Input.GetKey(KeyCode.LeftArrow) && myRB.transform.position.x > -8) { myRB.AddForce(Vector3.left * velVal); } if (Input.GetKey(KeyCode.RightArrow) && myRB.transform.position.x < 8) { myRB.AddForce(Vector3.right * velVal); } if (Input.GetKey(KeyCode.UpArrow) && myRB.transform.position.y < 8) { myRB.AddForce(Vector3.up * velVal); } if (Input.GetKey(KeyCode.DownArrow) && myRB.transform.position.y > -8) { myRB.AddForce(Vector3.down * velVal); } if (!moving) { myRB.velocity = Vector3.zero; } #endregion #region Application Quit Code if (Input.GetKeyDown(KeyCode.Escape)) { Application.Quit(); } #endregion if (Input.GetKeyDown(KeyCode.T)) { var s = new HapticSequence(); s.AddEffect(0.0, new HapticEffect(Effect.Click)); s.Play(AreaFlag.Left_All); long milliseconds = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; Debug.Log("Milliseconds: " + milliseconds); } }
public void Dig() { //Debug.Log("Attempted Dig\n", this); //Are we held. //if (IsGrabbed()) //{ HapticSequence seq = new HapticSequence(); seq.AddEffect(.25f, new HapticEffect(Effect.Buzz)); AreaFlag Where = PrimaryLeft ? AreaFlag.Forearm_Left : AreaFlag.Forearm_Right; seq.Play(Where); //} Digged = true; leftActions.TriggerDecayingHapticPulse(1f, .5f, .02f, .8f); rightActions.TriggerDecayingHapticPulse(1f, .5f, .02f, .8f); }
/// <summary> /// Shoots the player body somewhere with a simple buzz emanation impulse. /// </summary> /// <param name="ShotWhere">Self explanator. DO NOT PROVIDE MULTIPLE AREAS.</param> /// <returns>Don't forget to call .Play() on the returned Impulse to create an instance of the haptic effect it defines.</returns> public static ImpulseGenerator.Impulse DesertOfDangerShot(AreaFlag ShotWhere = AreaFlag.Chest_Right) { HapticSequence seq = new HapticSequence(); //This will be slightly different then the default Effect.Buzz effect Impulse. If you ask for an effect with a duration of 0, it'll play the natural duration. //Natural durations range from .05s (click, buzz, etc) to .25s (the multiple click families) //So by providing a duration of .1, this will be slightly different than the line: // HapticEffect eff = new HapticEffect(Effect.Buzz, 0.00f, 1.0f); HapticEffect eff = new HapticEffect(Effect.Buzz, 0.10f); seq.AddEffect(0, eff); //The Desert of Danger demo set the entire impulse duration to .25s, //this means that it emanated out from where the playerwas hit. return(ImpulseGenerator.BeginEmanatingEffect(ShotWhere) .WithEffect(seq) .WithDuration(.25f)); }
public void SetTriggerSequence(string sequenceName, string visibleName) { //HapticSequence newSeq = new HapticSequence(); try { LastSequence = new HapticSequence(); LastSequence.LoadFromAsset(sequenceName); greenBox.SetSequence(LastSequence); } catch (HapticsAssetException hExcept) { Debug.LogError("[Library Manager - Haptics Asset Exception] Exception while loading sequence - " + sequenceName + "\n\t" + hExcept.Message); } catch (System.Exception e) { Debug.LogError("[Exception] \n\tLoad failed and set was disallowed\n" + e.Message); } LastSequenceName = visibleName; greenBoxText.text = visibleName; }