Update LeanTween to 2.46

PortraitController forces alpha and color tweens to be non recursive.
7 years ago · a7fe939981
18 changed files with 6532 additions and 5066 deletions
--- a/Assets/Fungus/Scripts/Components/PortraitController.cs
+++ b/Assets/Fungus/Scripts/Components/PortraitController.cs
@ -203,7 +203,7 @@ namespace Fungus
            float duration = (fadeDuration > 0f) ? fadeDuration : float.Epsilon;

            // Fade in character image (first time)
-            LeanTween.alpha(portraitImage.transform as RectTransform, 1f, duration).setEase(stage.FadeEaseType);
+            LeanTween.alpha(portraitImage.transform as RectTransform, 1f, duration).setEase(stage.FadeEaseType).setRecursive(false);

            // Tell character about portrait image
            character.State.portraitImage = portraitImage;
@ -455,7 +455,7 @@ namespace Fungus
            float duration = (options.fadeDuration > 0f) ? options.fadeDuration : float.Epsilon;

            // Fade out a duplicate of the existing portrait image
-            if (options.character.State.portraitImage != null)
+            if (options.character.State.portraitImage != null && options.character.State.portraitImage.sprite != null)
            {
                GameObject tempGO = GameObject.Instantiate(options.character.State.portraitImage.gameObject);
                tempGO.transform.SetParent(options.character.State.portraitImage.transform, false);
@ -469,7 +469,7 @@ namespace Fungus

                LeanTween.alpha(tempImage.rectTransform, 0f, duration).setEase(stage.FadeEaseType).setOnComplete(() => {
                    Destroy(tempGO);
-                });
+                }).setRecursive(false);
            }

            // Fade in the new sprite image
@ -478,7 +478,7 @@ namespace Fungus
            {
                options.character.State.portraitImage.sprite = options.portrait;
                options.character.State.portraitImage.color = new Color(1f, 1f, 1f, 0f);
-                LeanTween.alpha(options.character.State.portraitImage.rectTransform, 1f, duration).setEase(stage.FadeEaseType);
+                LeanTween.alpha(options.character.State.portraitImage.rectTransform, 1f, duration).setEase(stage.FadeEaseType).setRecursive(false);
            }

            DoMoveTween(options);
@ -577,7 +577,7 @@ namespace Fungus
            // LeanTween doesn't handle 0 duration properly
            float duration = (options.fadeDuration > 0f) ? options.fadeDuration : float.Epsilon;

-            LeanTween.alpha(options.character.State.portraitImage.rectTransform, 0f, duration).setEase(stage.FadeEaseType);
+            LeanTween.alpha(options.character.State.portraitImage.rectTransform, 0f, duration).setEase(stage.FadeEaseType).setRecursive(false);

            DoMoveTween(options);

@ -610,7 +610,7 @@ namespace Fungus
            // LeanTween doesn't handle 0 duration properly
            float duration = (stage.FadeDuration > 0f) ? stage.FadeDuration : float.Epsilon;

-            LeanTween.color(character.State.portraitImage.rectTransform, targetColor, duration).setEase(stage.FadeEaseType);
+            LeanTween.color(character.State.portraitImage.rectTransform, targetColor, duration).setEase(stage.FadeEaseType).setRecursive(false);
        }

        #endregion
--- a/Assets/Fungus/Thirdparty/LeanTween.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween.meta
@ -1,2 +1,8 @@
 fileFormatVersion: 2
 guid: 5e6a0fa47acf54892bbdae89028eaec3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Fungus/Thirdparty/LeanTween/LTDescr.cs
+++ b/Assets/Fungus/Thirdparty/LeanTween/LTDescr.cs
--- a/Assets/Fungus/Thirdparty/LeanTween/LTDescr.cs.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/LTDescr.cs.meta
@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 381c8d6fb1acdc348870a7147bc98723
+timeCreated: 1463137984
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Fungus/Thirdparty/LeanTween/LTDescrOptional.cs
+++ b/Assets/Fungus/Thirdparty/LeanTween/LTDescrOptional.cs
@ -0,0 +1,88 @@
+//namespace DentedPixel{
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+public class LTDescrOptional  {
+
+	public Transform toTrans { get; set; }
+	public Vector3 point { get; set; }
+	public Vector3 axis { get; set; }
+    public float lastVal{ get; set; }
+	public Quaternion origRotation { get; set; }
+	public LTBezierPath path { get; set; }
+	public LTSpline spline { get; set; }
+	public AnimationCurve animationCurve;
+	public int initFrameCount;
+
+	public LTRect ltRect { get; set; } // maybe get rid of this eventually
+
+	public Action<float> onUpdateFloat { get; set; }
+	public Action<float,float> onUpdateFloatRatio { get; set; }
+	public Action<float,object> onUpdateFloatObject { get; set; }
+	public Action<Vector2> onUpdateVector2 { get; set; }
+	public Action<Vector3> onUpdateVector3 { get; set; }
+	public Action<Vector3,object> onUpdateVector3Object { get; set; }
+	public Action<Color> onUpdateColor { get; set; }
+	public Action<Color,object> onUpdateColorObject { get; set; }
+	public Action onComplete { get; set; }
+	public Action<object> onCompleteObject { get; set; }
+	public object onCompleteParam { get; set; }
+	public object onUpdateParam { get; set; }
+	public Action onStart { get; set; }
+
+
+//	#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
+//	public SpriteRenderer spriteRen { get; set; }
+//	#endif
+//
+//	#if LEANTWEEN_1
+//	public Hashtable optional;
+//	#endif
+//	#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
+//	public RectTransform rectTransform;
+//	public UnityEngine.UI.Text uiText;
+//	public UnityEngine.UI.Image uiImage;
+//	public UnityEngine.Sprite[] sprites;
+//	#endif
+
+
+	public void reset(){
+		animationCurve = null;
+
+		this.onUpdateFloat = null;
+		this.onUpdateFloatRatio = null;
+		this.onUpdateVector2 = null;
+		this.onUpdateVector3 = null;
+		this.onUpdateFloatObject = null;
+		this.onUpdateVector3Object = null;
+		this.onUpdateColor = null;
+		this.onComplete = null;
+		this.onCompleteObject = null;
+		this.onCompleteParam = null;
+		this.onStart = null;
+
+		this.point = Vector3.zero;
+		this.initFrameCount = 0;
+	}
+
+	public void callOnUpdate( float val, float ratioPassed){
+		if(this.onUpdateFloat!=null)
+			this.onUpdateFloat(val);
+
+		if (this.onUpdateFloatRatio != null){
+			this.onUpdateFloatRatio(val,ratioPassed);
+		}else if(this.onUpdateFloatObject!=null){
+			this.onUpdateFloatObject(val, this.onUpdateParam);
+		}else if(this.onUpdateVector3Object!=null){
+			this.onUpdateVector3Object(LTDescr.newVect, this.onUpdateParam);
+		}else if(this.onUpdateVector3!=null){
+			this.onUpdateVector3(LTDescr.newVect);
+		}else if(this.onUpdateVector2!=null){
+			this.onUpdateVector2(new Vector2(LTDescr.newVect.x,LTDescr.newVect.y));
+		}
+	}
+}
+
+//}
--- a/Assets/Fungus/Thirdparty/LeanTween/LTDescrOptional.cs.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/LTDescrOptional.cs.meta
@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c1ba8f1ef97134cb39b52ae26678db63
+timeCreated: 1471504769
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Fungus/Thirdparty/LeanTween/LTSeq.cs
+++ b/Assets/Fungus/Thirdparty/LeanTween/LTSeq.cs
@ -0,0 +1,227 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+/**
+* Internal Representation of a Sequence<br>
+* <br>
+* &nbsp;&nbsp;<h4>Example:</h4> 
+* var seq = LeanTween.sequence();<br>
+* seq.append(1f); <span style="color:gray">// delay everything one second</span><br>
+* seq.append( () => { <span style="color:gray">// fire an event before start</span><br>
+* &nbsp;Debug.Log("I have started");<br>
+* });<br>
+* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); <span style="color:gray">// do a tween</span><br>
+* seq.append( (object obj) => { <span style="color:gray">// fire event after tween</span><br>
+* &nbsp;var dict = obj as Dictionary<string,string>;<br>
+* &nbsp;Debug.Log("We are done now obj value:"+dict["hi"]);<br>
+* }, new Dictionary<string,string>(){ {"hi","sup"} } );<br>
+* @class LTSeq
+* @constructor
+*/
+public class LTSeq {
+
+	public LTSeq previous;
+
+	public LTSeq current;
+
+	public LTDescr tween;
+
+	public float totalDelay;
+
+	public float timeScale;
+
+	private int debugIter;
+
+	public uint counter;
+
+	public bool toggle = false;
+
+	private uint _id;
+
+	public int id{
+		get{ 
+			uint toId = _id | counter << 16;
+
+			/*uint backId = toId & 0xFFFF;
+			uint backCounter = toId >> 16;
+			if(_id!=backId || backCounter!=counter){
+				Debug.LogError("BAD CONVERSION toId:"+_id);
+			}*/
+
+			return (int)toId;
+		}
+	}
+
+	public void reset(){
+		previous = null;
+		tween = null;
+		totalDelay = 0f;
+	}
+
+	public void init(uint id, uint global_counter){
+		reset();
+		_id = id;
+
+		counter = global_counter;
+
+		this.current = this;
+	}
+
+	private LTSeq addOn(){
+		this.current.toggle = true;
+		LTSeq lastCurrent = this.current;
+		this.current = LeanTween.sequence(true);
+		Debug.Log("this.current:" + this.current.id + " lastCurrent:" + lastCurrent.id);
+		this.current.previous = lastCurrent;
+		lastCurrent.toggle = false;
+		this.current.totalDelay = lastCurrent.totalDelay;
+		this.current.debugIter = lastCurrent.debugIter + 1;
+		return current;
+	}
+
+	private float addPreviousDelays(){
+//		Debug.Log("delay:"+delay+" count:"+this.current.count+" this.current.totalDelay:"+this.current.totalDelay);
+
+		LTSeq prev = this.current.previous;
+
+		if (prev != null && prev.tween!=null) {
+            return this.current.totalDelay + prev.tween.time;
+		}
+        return this.current.totalDelay;
+	}
+
+	/**
+	* Add a time delay to the sequence
+	* @method append (delay)
+	* @param {float} delay:float amount of time to add to the sequence
+	* @return {LTSeq} LTDescr an object that distinguishes the tween
+	* var seq = LeanTween.sequence();<br>
+	* seq.append(1f); // delay everything one second<br>
+	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a tween<br>
+	*/
+	public LTSeq append( float delay ){
+        this.current.totalDelay += delay;
+
+		return this.current;
+	}
+
+	/**
+	* Add a time delay to the sequence
+	* @method append (method)
+	* @param {System.Action} callback:System.Action method you want to be called
+	* @return {LTSeq} LTSeq an object that you can add tweens, methods and time on to
+	* @example
+	* var seq = LeanTween.sequence();<br>
+	* seq.append( () => { // fire an event before start<br>
+	* &nbsp;Debug.Log("I have started");<br>
+	* });<br>
+	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a tween<br>
+	* seq.append( () => { // fire event after tween<br>
+	* &nbsp;Debug.Log("We are done now");<br>
+	* });;<br>
+	*/
+	public LTSeq append( System.Action callback ){
+		LTDescr newTween = LeanTween.delayedCall(0f, callback);
+//		Debug.Log("newTween:" + newTween);
+		append(newTween);
+
+		return addOn();
+	}
+
+	/**
+	* Add a time delay to the sequence
+	* @method add (method(object))
+	* @param {System.Action} callback:System.Action method you want to be called
+	* @return {LTSeq} LTSeq an object that you can add tweens, methods and time on to
+	* @example
+	* var seq = LeanTween.sequence();<br>
+	* seq.append( () => { // fire an event before start<br>
+	* &nbsp;Debug.Log("I have started");<br>
+	* });<br>
+	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a tween<br>
+	* seq.append((object obj) => { // fire event after tween
+	* &nbsp;var dict = obj as Dictionary<string,string>;
+	* &nbsp;Debug.Log("We are done now obj value:"+dict["hi"]);
+	* &nbsp;}, new Dictionary<string,string>(){ {"hi","sup"} } );
+	*/
+	public LTSeq append( System.Action<object> callback, object obj ){
+		append(LeanTween.delayedCall(0f, callback).setOnCompleteParam(obj));
+
+		return addOn();
+	}
+
+	public LTSeq append( GameObject gameObject, System.Action callback ){
+		append(LeanTween.delayedCall(gameObject, 0f, callback));
+
+		return addOn();
+	}
+
+	public LTSeq append( GameObject gameObject, System.Action<object> callback, object obj ){
+		append(LeanTween.delayedCall(gameObject, 0f, callback).setOnCompleteParam(obj));
+
+		return addOn();
+	}
+
+	/**
+	* Retrieve a sequencer object where you can easily chain together tweens and methods one after another
+	* 
+	* @method add (tween)
+	* @return {LTSeq} LTSeq an object that you can add tweens, methods and time on to
+	* @example
+	* var seq = LeanTween.sequence();<br>
+	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a move tween<br>
+	* seq.append( LeanTween.rotateAround( avatar1, Vector3.forward, 360f, 1f ) ); // then do a rotate tween<br>
+	*/
+	public LTSeq append( LTDescr tween ){
+		this.current.tween = tween;
+
+//		Debug.Log("tween:" + tween + " delay:" + this.current.totalDelay);
+
+        this.current.totalDelay = addPreviousDelays();
+
+		tween.setDelay( this.current.totalDelay );
+
+		return addOn();
+	}
+
+	public LTSeq insert( LTDescr tween ){
+		this.current.tween = tween;
+
+        tween.setDelay( addPreviousDelays() );
+
+		return addOn();
+	}
+
+
+	public LTSeq setScale( float timeScale ){
+//		Debug.Log("this.current:" + this.current.previous.debugIter+" tween:"+this.current.previous.tween);
+		setScaleRecursive(this.current, timeScale, 500);
+
+		return addOn();
+	}
+
+	private void setScaleRecursive( LTSeq seq, float timeScale, int count ){
+		if (count > 0) {
+			this.timeScale = timeScale;
+
+//			Debug.Log("seq.count:" + count + " seq.tween:" + seq.tween);
+			seq.totalDelay *= timeScale;
+			if (seq.tween != null) {
+//			Debug.Log("seq.tween.time * timeScale:" + seq.tween.time * timeScale + " seq.totalDelay:"+seq.totalDelay +" time:"+seq.tween.time+" seq.tween.delay:"+seq.tween.delay);
+				if (seq.tween.time != 0f)
+					seq.tween.setTime(seq.tween.time * timeScale);
+				seq.tween.setDelay(seq.tween.delay * timeScale);
+			}
+
+			if (seq.previous != null)
+				setScaleRecursive(seq.previous, timeScale, count - 1);
+		}
+	}
+
+	public LTSeq reverse(){
+
+		return addOn();
+	}
+
+}
--- a/Assets/Fungus/Thirdparty/LeanTween/LTSeq.cs.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/LTSeq.cs.meta
@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6c88dbe4cdd9944f198e9796ee394c86
+timeCreated: 1488665079
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanAudio.cs
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanAudio.cs
@ -0,0 +1,418 @@
+
+using UnityEngine;
+using System.Collections.Generic;
+
+public class LeanAudioStream {
+
+	public int position = 0;
+
+	public AudioClip audioClip;
+	public float[] audioArr;
+
+	public LeanAudioStream( float[] audioArr ){
+		this.audioArr = audioArr;
+	}
+
+	public void OnAudioRead(float[] data) {
+        int count = 0;
+        while (count < data.Length) {
+            data[count] = audioArr[this.position];
+            position++;
+            count++;
+        }
+    }
+
+    public void OnAudioSetPosition(int newPosition) {
+    	this.position = newPosition;   
+    }
+}
+
+/**
+* Create Audio dynamically and easily playback
+*
+* @class LeanAudio
+* @constructor
+*/
+public class LeanAudio : object {
+
+	public static float MIN_FREQEUNCY_PERIOD = 0.000115f;
+	public static int PROCESSING_ITERATIONS_MAX = 50000;
+	public static float[] generatedWaveDistances;
+	public static int generatedWaveDistancesCount = 0;
+
+	private static float[] longList;
+
+	public static LeanAudioOptions options(){
+		if(generatedWaveDistances==null){
+			generatedWaveDistances = new float[ PROCESSING_ITERATIONS_MAX ];
+			longList = new float[ PROCESSING_ITERATIONS_MAX ];
+		}
+		return new LeanAudioOptions();
+	}
+
+	public static LeanAudioStream createAudioStream( AnimationCurve volume, AnimationCurve frequency, LeanAudioOptions options = null ){
+		if(options==null)
+			options = new LeanAudioOptions();
+
+		options.useSetData = false;
+
+		int generatedWavePtsLength = createAudioWave( volume, frequency, options);
+		createAudioFromWave( generatedWavePtsLength, options );
+
+		return options.stream;
+	}
+
+	/**
+	* Create dynamic audio from a set of Animation Curves and other options.
+	* 
+	* @method createAudio
+	* @param {AnimationCurve} volumeCurve:AnimationCurve describing the shape of the audios volume (from 0-1). The length of the audio is dicated by the end value here.
+	* @param {AnimationCurve} frequencyCurve:AnimationCurve describing the width of the oscillations between the sound waves in seconds. Large numbers mean a lower note, while higher numbers mean a tighter frequency and therefor a higher note. Values are usually between 0.01 and 0.000001 (or smaller)
+	* @param {LeanAudioOptions} options:LeanAudioOptions You can pass any other values in here like vibrato or the frequency you would like the sound to be encoded at. See <a href="LeanAudioOptions.html">LeanAudioOptions</a> for more details.
+	* @return {AudioClip} AudioClip of the procedurally generated audio
+	* @example
+	* AnimationCurve volumeCurve = new AnimationCurve( new Keyframe(0f, 1f, 0f, -1f), new Keyframe(1f, 0f, -1f, 0f));<br>
+	* AnimationCurve frequencyCurve = new AnimationCurve( new Keyframe(0f, 0.003f, 0f, 0f), new Keyframe(1f, 0.003f, 0f, 0f));<br>
+	* AudioClip audioClip = LeanAudio.createAudio(volumeCurve, frequencyCurve, LeanAudio.options().setVibrato( new Vector3[]{ new Vector3(0.32f,0f,0f)} ));<br>
+	*/
+	public static AudioClip createAudio( AnimationCurve volume, AnimationCurve frequency, LeanAudioOptions options = null ){
+		if(options==null)
+			options = new LeanAudioOptions();
+		
+		int generatedWavePtsLength = createAudioWave( volume, frequency, options);
+		// Debug.Log("generatedWavePtsLength:"+generatedWavePtsLength);
+		return createAudioFromWave( generatedWavePtsLength, options );
+	}
+
+	private static int createAudioWave( AnimationCurve volume, AnimationCurve frequency, LeanAudioOptions options ){
+		float time = volume[ volume.length - 1 ].time;
+		int listLength = 0;
+		// List<float> list = new List<float>();
+
+		// generatedWaveDistances = new List<float>();
+		// float[] vibratoValues = new float[ vibrato.Length ];
+		float passed = 0f;
+		for(int i = 0; i < PROCESSING_ITERATIONS_MAX; i++){
+			float f = frequency.Evaluate(passed);
+			if(f<MIN_FREQEUNCY_PERIOD)
+				f = MIN_FREQEUNCY_PERIOD;
+			float height = volume.Evaluate(passed + 0.5f*f);
+			if(options.vibrato!=null){
+				for(int j=0; j<options.vibrato.Length; j++){
+					float peakMulti = Mathf.Abs( Mathf.Sin( 1.5708f + passed * (1f/options.vibrato[j][0]) * Mathf.PI ) );
+					float diff = (1f-options.vibrato[j][1]);
+					peakMulti = options.vibrato[j][1] + diff*peakMulti;
+					height *= peakMulti;
+				}	
+			}
+
+			
+			// Debug.Log("i:"+i+" f:"+f+" passed:"+passed+" height:"+height+" time:"+time);
+			if(passed + 0.5f*f>=time)
+				break;
+			if(listLength >= PROCESSING_ITERATIONS_MAX-1){
+				Debug.LogError("LeanAudio has reached it's processing cap. To avoid this error increase the number of iterations ex: LeanAudio.PROCESSING_ITERATIONS_MAX = "+(PROCESSING_ITERATIONS_MAX*2));
+				break;
+			}else{
+				int distPoint = listLength / 2;
+				
+				//generatedWaveDistances.Add( f );
+				passed += f;
+
+				generatedWaveDistances[ distPoint ] = passed;
+				//Debug.Log("distPoint:"+distPoint+" passed:"+passed);
+
+				//list.Add( passed );
+				//list.Add( i%2==0 ? -height : height );
+
+				longList[ listLength ] = passed;
+				longList[ listLength + 1 ] = i%2==0 ? -height : height;
+			}
+
+			
+
+			listLength += 2;
+			
+		}
+
+		listLength += -2;
+		generatedWaveDistancesCount = listLength / 2;
+
+		/*float[] wave = new float[ listLength ];
+		for(int i = 0; i < wave.Length; i++){
+			wave[i] = longList[i];
+		}*/
+		return listLength;
+	}
+
+	private static AudioClip createAudioFromWave( int waveLength, LeanAudioOptions options ){
+		float time = longList[ waveLength - 2 ];
+		float[] audioArr = new float[ (int)(options.frequencyRate*time) ];
+
+		int waveIter = 0;
+		float subWaveDiff = longList[waveIter];
+		float subWaveTimeLast = 0f;
+		float subWaveTime = longList[waveIter];
+		float waveHeight = longList[waveIter+1];
+		for(int i = 0; i < audioArr.Length; i++){
+			float passedTime = (float)i / (float)options.frequencyRate;
+			if(passedTime > longList[waveIter] ){
+				subWaveTimeLast = longList[waveIter];
+				waveIter += 2;
+				subWaveDiff = longList[waveIter] - longList[waveIter-2];
+				waveHeight = longList[waveIter+1];
+				// Debug.Log("passed wave i:"+i);
+			}
+			subWaveTime = passedTime - subWaveTimeLast;
+			float ratioElapsed = subWaveTime / subWaveDiff;
+
+			float value = Mathf.Sin( ratioElapsed * Mathf.PI );
+
+			if(options.waveStyle==LeanAudioOptions.LeanAudioWaveStyle.Square){
+				if(value>0f)
+					value = 1f;
+				if(value<0f)
+					value = -1f;
+			}else if(options.waveStyle==LeanAudioOptions.LeanAudioWaveStyle.Sawtooth){
+				float sign = value > 0f ? 1f : -1f;
+				if(ratioElapsed<0.5f){
+					value = (ratioElapsed*2f)*sign;
+				}else{ // 0.5f - 1f
+					value = (1f - ratioElapsed)*2f*sign;
+				}
+			}else if(options.waveStyle==LeanAudioOptions.LeanAudioWaveStyle.Noise){
+				float peakMulti = (1f-options.waveNoiseInfluence) + Mathf.PerlinNoise(0f, passedTime * options.waveNoiseScale ) * options.waveNoiseInfluence;
+				
+				/*if(i<25){
+					Debug.Log("passedTime:"+passedTime+" peakMulti:"+peakMulti+" infl:"+options.waveNoiseInfluence);
+				}*/
+
+				value *= peakMulti;
+			}
+			
+			//if(i<25)
+			//	Debug.Log("passedTime:"+passedTime+" value:"+value+" ratioElapsed:"+ratioElapsed+" subWaveTime:"+subWaveTime+" subWaveDiff:"+subWaveDiff);
+			
+			value *= waveHeight;
+
+
+			if(options.modulation!=null){
+				for(int k=0; k<options.modulation.Length; k++){
+					float peakMulti = Mathf.Abs( Mathf.Sin( 1.5708f + passedTime * (1f/options.modulation[k][0]) * Mathf.PI ) );
+					float diff = (1f-options.modulation[k][1]);
+					peakMulti = options.modulation[k][1] + diff*peakMulti;
+					// if(k<10){
+						// Debug.Log("k:"+k+" peakMulti:"+peakMulti+" value:"+value+" after:"+(value*peakMulti));
+					// }
+					value *= peakMulti;
+				}	
+			}
+
+			audioArr[i] = value;
+			// Debug.Log("pt:"+pt+" i:"+i+" val:"+audioArr[i]+" len:"+audioArr.Length);
+		}
+
+		
+		int lengthSamples = audioArr.Length;
+		
+		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7
+		bool is3dSound = false;
+		AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, options.frequencyRate, is3dSound, false);
+		#else
+		AudioClip audioClip = null;
+		if(options.useSetData){
+			audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, options.frequencyRate, false, null, OnAudioSetPosition);
+			audioClip.SetData(audioArr, 0);
+		}else{
+			options.stream = new LeanAudioStream(audioArr);
+			// Debug.Log("len:"+audioArr.Length+" lengthSamples:"+lengthSamples+" freqRate:"+options.frequencyRate);
+			audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, options.frequencyRate, false, options.stream.OnAudioRead, options.stream.OnAudioSetPosition);
+			options.stream.audioClip = audioClip;
+		}
+		
+		#endif
+
+		return audioClip;
+	}
+
+	private static void OnAudioSetPosition(int newPosition) {
+        
+    }
+
+	public static AudioClip generateAudioFromCurve( AnimationCurve curve, int frequencyRate = 44100 ){
+		float curveTime = curve[ curve.length - 1 ].time;
+		float time = curveTime;
+		float[] audioArr = new float[ (int)(frequencyRate*time) ];
+
+		// Debug.Log("curveTime:"+curveTime+" AudioSettings.outputSampleRate:"+AudioSettings.outputSampleRate);
+		for(int i = 0; i < audioArr.Length; i++){
+			float pt = (float)i / (float)frequencyRate;
+			audioArr[i] = curve.Evaluate( pt );
+			// Debug.Log("pt:"+pt+" i:"+i+" val:"+audioArr[i]+" len:"+audioArr.Length);
+		}
+
+		int lengthSamples = audioArr.Length;//(int)( (float)frequencyRate * curveTime );
+		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7
+		bool is3dSound = false;
+		AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, frequencyRate, is3dSound, false);
+		#else
+		AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, frequencyRate, false);
+		#endif
+		audioClip.SetData(audioArr, 0);
+
+		return audioClip;
+	}
+
+	public static AudioSource play( AudioClip audio, float volume ){
+		AudioSource audioSource = playClipAt(audio, Vector3.zero);
+		audioSource.volume = volume;
+		return audioSource; 
+	}
+
+	public static AudioSource play( AudioClip audio ){
+		return playClipAt( audio, Vector3.zero ); 
+	}
+
+	public static AudioSource play( AudioClip audio, Vector3 pos ){
+		return playClipAt( audio, pos ); 
+	}
+
+	public static AudioSource play( AudioClip audio, Vector3 pos, float volume ){
+		// Debug.Log("audio length:"+audio.length);
+		AudioSource audioSource = playClipAt(audio, pos);
+		audioSource.minDistance = 1f;
+		//audioSource.pitch = pitch;
+		audioSource.volume = volume;
+
+		return audioSource;
+	}
+
+	public static AudioSource playClipAt( AudioClip clip, Vector3 pos ) {
+		GameObject tempGO = new GameObject(); // create the temp object
+		tempGO.transform.position = pos; // set its position
+		AudioSource aSource = tempGO.AddComponent<AudioSource>(); // add an audio source
+		aSource.clip = clip; // define the clip
+		aSource.Play(); // start the sound
+		GameObject.Destroy(tempGO, clip.length); // destroy object after clip duration
+		return aSource; // return the AudioSource reference
+	}
+
+	public static void printOutAudioClip( AudioClip audioClip, ref AnimationCurve curve, float scaleX = 1f ){
+		// Debug.Log("Audio channels:"+audioClip.channels+" frequency:"+audioClip.frequency+" length:"+audioClip.length+" samples:"+audioClip.samples);
+		float[] samples = new float[audioClip.samples * audioClip.channels];
+        audioClip.GetData(samples, 0);
+        int i = 0;
+
+        Keyframe[] frames = new Keyframe[samples.Length];
+        while (i < samples.Length) {
+           frames[i] = new Keyframe( (float)i * scaleX, samples[i] );
+           ++i;
+        }
+        curve = new AnimationCurve( frames );
+	}
+}
+
+
+/**
+* Pass in options to LeanAudio
+*
+* @class LeanAudioOptions
+* @constructor
+*/
+public class LeanAudioOptions : object {
+
+	public enum LeanAudioWaveStyle{
+		Sine,
+		Square,
+		Sawtooth,
+		Noise
+	}
+
+	public LeanAudioWaveStyle waveStyle = LeanAudioWaveStyle.Sine;
+	public Vector3[] vibrato;
+	public Vector3[] modulation;
+	public int frequencyRate = 44100;
+	public float waveNoiseScale = 1000;
+	public float waveNoiseInfluence = 1f;
+
+	public bool useSetData = true;
+	public LeanAudioStream stream;
+
+	public LeanAudioOptions(){}
+
+	/**
+	* Set the frequency for the audio is encoded. 44100 is CD quality, but you can usually get away with much lower (or use a lower amount to get a more 8-bit sound).
+	* 
+	* @method setFrequency
+	* @param {int} frequencyRate:int of the frequency you wish to encode the AudioClip at
+	* @return {LeanAudioOptions} LeanAudioOptions describing optional values
+	* @example
+	* AnimationCurve volumeCurve = new AnimationCurve( new Keyframe(0f, 1f, 0f, -1f), new Keyframe(1f, 0f, -1f, 0f));<br>
+	* AnimationCurve frequencyCurve = new AnimationCurve( new Keyframe(0f, 0.003f, 0f, 0f), new Keyframe(1f, 0.003f, 0f, 0f));<br>
+	* AudioClip audioClip = LeanAudio.createAudio(volumeCurve, frequencyCurve, LeanAudio.options().setVibrato( new Vector3[]{ new Vector3(0.32f,0f,0f)} ).setFrequency(12100) );<br>
+	*/
+	public LeanAudioOptions setFrequency( int frequencyRate ){
+		this.frequencyRate = frequencyRate;
+		return this;
+	}
+
+	/**
+	* Set details about the shape of the curve by adding vibrato modulations through it (alters the peak values giving it a wah-wah effect). You can add as many as you want to sculpt out more detail in the sound wave.
+	* 
+	* @method setVibrato
+	* @param {Vector3[]} vibratoArray:Vector3[] The first value is the period in seconds that you wish to have the vibrato wave fluctuate at. The second value is the minimum height you wish the vibrato wave to dip down to (default is zero). The third is reserved for future effects.
+	* @return {LeanAudioOptions} LeanAudioOptions describing optional values
+	* @example
+	* AnimationCurve volumeCurve = new AnimationCurve( new Keyframe(0f, 1f, 0f, -1f), new Keyframe(1f, 0f, -1f, 0f));<br>
+	* AnimationCurve frequencyCurve = new AnimationCurve( new Keyframe(0f, 0.003f, 0f, 0f), new Keyframe(1f, 0.003f, 0f, 0f));<br>
+	* AudioClip audioClip = LeanAudio.createAudio(volumeCurve, frequencyCurve, LeanAudio.options().setVibrato( new Vector3[]{ new Vector3(0.32f,0.3f,0f)} ).setFrequency(12100) );<br>
+	*/
+	public LeanAudioOptions setVibrato( Vector3[] vibrato ){
+		this.vibrato = vibrato;
+		return this;
+	}
+
+	/*
+	public LeanAudioOptions setModulation( Vector3[] modulation ){
+		this.modulation = modulation;
+		return this;
+	}*/
+
+	public LeanAudioOptions setWaveSine(){
+		this.waveStyle = LeanAudioWaveStyle.Sine;
+		return this;
+	}
+
+	public LeanAudioOptions setWaveSquare(){
+		this.waveStyle = LeanAudioWaveStyle.Square;
+		return this;
+	}
+
+	public LeanAudioOptions setWaveSawtooth(){
+		this.waveStyle = LeanAudioWaveStyle.Sawtooth;
+		return this;
+	}
+
+	public LeanAudioOptions setWaveNoise(){
+		this.waveStyle = LeanAudioWaveStyle.Noise;
+		return this;
+	}
+
+	public LeanAudioOptions setWaveStyle( LeanAudioWaveStyle style ){
+		this.waveStyle = style;
+		return this;
+	}
+
+
+	public LeanAudioOptions setWaveNoiseScale( float waveScale ){
+		this.waveNoiseScale = waveScale;
+		return this;
+	}
+
+	public LeanAudioOptions setWaveNoiseInfluence( float influence ){
+		this.waveNoiseInfluence = influence;
+		return this;
+	}
+}
+
+
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanAudio.cs.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanAudio.cs.meta
@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 52e41e970d9353942b27458440bec9eb
+timeCreated: 1427917971
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanTest.cs
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanTest.cs
@ -0,0 +1,123 @@
+using UnityEngine;
+using System.Collections;
+
+public class LeanTester : MonoBehaviour {
+	public float timeout = 15f;
+
+	#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
+	public void Start(){
+		StartCoroutine( timeoutCheck() );
+	}
+
+	IEnumerator timeoutCheck(){
+		float pauseEndTime = Time.realtimeSinceStartup + timeout;
+	    while (Time.realtimeSinceStartup < pauseEndTime)
+	    {
+	        yield return 0;
+	    }
+		if(LeanTest.testsFinished==false){
+			Debug.Log(LeanTest.formatB("Tests timed out!"));
+			LeanTest.overview();
+		}
+	}
+	#endif
+}
+
+public class LeanTest : object {
+	public static int expected = 0;
+	private static int tests = 0;
+	private static int passes = 0;
+
+	public static float timeout = 15f;
+	public static bool timeoutStarted = false;
+	public static bool testsFinished = false;
+	
+	public static void debug( string name, bool didPass, string failExplaination = null){
+		expect( didPass, name, failExplaination);
+	}
+
+	public static void expect( bool didPass, string definition, string failExplaination = null){
+		float len = printOutLength(definition);
+		int paddingLen = 40-(int)(len*1.05f);
+		#if UNITY_FLASH
+		string padding = padRight(paddingLen);
+		#else
+		string padding = "".PadRight(paddingLen,"_"[0]);
+		#endif
+		string logName = formatB(definition) +" " + padding + " [ "+ (didPass ? formatC("pass","green") : formatC("fail","red")) +" ]";
+		if(didPass==false && failExplaination!=null)
+			logName += " - " + failExplaination;
+		Debug.Log(logName);
+		if(didPass)
+			passes++;
+		tests++;
+		
+		// Debug.Log("tests:"+tests+" expected:"+expected);
+		if(tests==expected && testsFinished==false){
+			overview();
+		}else if(tests>expected){
+			Debug.Log(formatB("Too many tests for a final report!") + " set LeanTest.expected = "+tests);
+		}
+
+		if(timeoutStarted==false){
+			timeoutStarted = true;
+			GameObject tester = new GameObject();
+			tester.name = "~LeanTest";
+			LeanTester test = tester.AddComponent(typeof(LeanTester)) as LeanTester;
+			test.timeout = timeout;
+			#if !UNITY_EDITOR
+			tester.hideFlags = HideFlags.HideAndDontSave;
+			#endif
+		}
+	}
+	
+	public static string padRight(int len){
+		string str = "";
+		for(int i = 0; i < len; i++){
+			str += "_";
+		}
+		return str;
+	}
+	
+	public static float printOutLength( string str ){
+		float len = 0.0f;
+		for(int i = 0; i < str.Length; i++){
+			if(str[i]=="I"[0]){
+				len += 0.5f;
+			}else if(str[i]=="J"[0]){
+				len += 0.85f;
+			}else{
+				len += 1.0f;
+			}
+		}
+		return len;
+	}
+	
+	public static string formatBC( string str, string color ){
+		return formatC(formatB(str),color);
+	}
+	
+	public static string formatB( string str ){
+		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
+		return str;
+		#else
+		return "<b>"+ str + "</b>";
+		#endif
+	}
+	
+	public static string formatC( string str, string color ){
+		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
+		return str;
+		#else
+		return "<color="+color+">"+ str + "</color>";
+		#endif
+	}
+	
+	public static void overview(){ 
+		testsFinished = true;
+		int failedCnt = (expected-passes);
+		string failedStr = failedCnt > 0 ? formatBC(""+failedCnt,"red") : ""+failedCnt;
+		Debug.Log(formatB("Final Report:")+" _____________________ PASSED: "+formatBC(""+passes,"green")+" FAILED: "+failedStr+" ");
+	}
+}
+	
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanTest.cs.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanTest.cs.meta
@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 82464f26ca2ba284a8f92f51248c574a
+timeCreated: 1427917971
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanTween.cs
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanTween.cs
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanTween.cs.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanTween.cs.meta
@ -1,6 +1,6 @@
 fileFormatVersion: 2
 guid: 9c2f4b27196f84954b44753aaac214bb
-timeCreated: 1445946121
+timeCreated: 1463137984
 licenseType: Store
 MonoImporter:
  serializedVersion: 2
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanTween.dll.zip
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanTween.dll.zip
--- a/Assets/Fungus/Thirdparty/LeanTween/LeanTween.dll.zip.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/LeanTween.dll.zip.meta
@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ffeadda6aaa064923a3f7e28ff26afb1
+timeCreated: 1477948563
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Fungus/Thirdparty/LeanTween/ReadMe.txt
+++ b/Assets/Fungus/Thirdparty/LeanTween/ReadMe.txt
@ -1,9 +0,0 @@
-LeanTween is an efficient tweening engine for Unity3d
-
-Full Documentation:
-	http://dentedpixel.com/LeanTweenDocumentation/classes/LeanTween.html
-	This can also be accessed offline! From the Unity menu Help->LeanTween Documentation
-
-Getting Started
-	
-	There are many examples included! Look in the “LeanTween/LeanTweenExamples" folder to see many of the methods outlined. 
--- a/Assets/Fungus/Thirdparty/LeanTween/ReadMe.txt.meta
+++ b/Assets/Fungus/Thirdparty/LeanTween/ReadMe.txt.meta
@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: f1e0da947b69648fdb1884d602088d92