COM_Diff/Assembly-CSharp/AMPropertyAction.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;

[Serializable]
public class AMPropertyAction : AMAction
{
	public PropertyInfo propertyInfo
	{
		get
		{
			if (this.cachedPropertyInfo != null)
			{
				return this.cachedPropertyInfo;
			}
			if (!this.component || this.propertyName == null)
			{
				return null;
			}
			this.cachedPropertyInfo = this.component.GetType().GetProperty(this.propertyName);
			return this.cachedPropertyInfo;
		}
		set
		{
			if (value != null)
			{
				this.propertyName = value.Name;
			}
			else
			{
				this.propertyName = null;
			}
			this.cachedPropertyInfo = value;
		}
	}

	public FieldInfo fieldInfo
	{
		get
		{
			if (this.cachedFieldInfo != null)
			{
				return this.cachedFieldInfo;
			}
			if (!this.component || this.fieldName == null)
			{
				return null;
			}
			this.cachedFieldInfo = this.component.GetType().GetField(this.fieldName);
			return this.cachedFieldInfo;
		}
		set
		{
			if (value != null)
			{
				this.fieldName = value.Name;
			}
			else
			{
				this.fieldName = null;
			}
			this.cachedFieldInfo = value;
		}
	}

	public MethodInfo methodInfo
	{
		get
		{
			if (this.cachedMethodInfo != null)
			{
				return this.cachedMethodInfo;
			}
			if (!this.component || this.methodName == null)
			{
				return null;
			}
			Type[] array = new Type[this.methodParameterTypes.Length];
			for (int i = 0; i < this.methodParameterTypes.Length; i++)
			{
				array[i] = Type.GetType(this.methodParameterTypes[i]);
			}
			this.cachedMethodInfo = this.component.GetType().GetMethod(this.methodName, array);
			return this.cachedMethodInfo;
		}
		set
		{
			if (value != null)
			{
				this.methodName = value.Name;
			}
			else
			{
				this.methodName = null;
			}
			this.cachedMethodInfo = value;
		}
	}

	public override string ToString(int codeLanguage, int frameRate)
	{
		if (this.endFrame == -1 || this.targetsAreEqual())
		{
			return null;
		}
		string text = string.Empty;
		if (this.fieldInfo != null)
		{
			text = "fieldinfo";
		}
		else if (this.propertyInfo != null)
		{
			text = "propertyinfo";
		}
		else
		{
			if (this.methodInfo == null)
			{
				Debug.LogError("Animator: No FieldInfo or PropertyInfo set.");
				return "( Error: No FieldInfo, PropertyInfo or MethodInfo set. )";
			}
			text = "methodinfo";
		}
		if (codeLanguage == 0)
		{
			if (this.valueType == 8)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, AMTween.Hash(\"delay\", ",
					base.getWaitTime(frameRate, 0f),
					"f, \"time\", ",
					this.getTime(frameRate),
					"f, \"",
					text,
					"\", obj.memberinfo, \"methodtype\", \"morph\", \"from\", ",
					this.getFloatArrayString(codeLanguage, this.start_morph),
					", \"to\", ",
					this.getFloatArrayString(codeLanguage, this.end_morph),
					", ",
					base.getEaseString(codeLanguage),
					"));"
				});
			}
			if (AMPropertyTrack.isValueTypeNumeric(this.valueType))
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, AMTween.Hash(\"delay\", ",
					base.getWaitTime(frameRate, 0f),
					"f, \"time\", ",
					this.getTime(frameRate),
					"f, \"",
					text,
					"\", obj.memberinfo, \"from\", ",
					this.start_val,
					"f,\"to\", ",
					this.end_val,
					"f, ",
					base.getEaseString(codeLanguage),
					"));"
				});
			}
			if (this.valueType == 4)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, AMTween.Hash(\"delay\", ",
					base.getWaitTime(frameRate, 0f),
					"f, \"time\", ",
					this.getTime(frameRate),
					"f, \"",
					text,
					"\", obj.memberinfo, \"from\", new Vector2(",
					this.start_vect2.x,
					"f, ",
					this.start_vect2.y,
					"f), \"to\", new Vector2(",
					this.end_vect2.x,
					"f, ",
					this.end_vect2.y,
					"f), ",
					base.getEaseString(codeLanguage),
					"));"
				});
			}
			if (this.valueType == 5)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, AMTween.Hash(\"delay\", ",
					base.getWaitTime(frameRate, 0f),
					"f, \"time\", ",
					this.getTime(frameRate),
					"f, \"",
					text,
					"\", obj.memberinfo, \"from\", new Vector3(",
					this.start_vect3.x,
					"f, ",
					this.start_vect3.y,
					"f, ",
					this.start_vect3.z,
					"f), \"to\", new Vector3(",
					this.end_vect3.x,
					"f, ",
					this.end_vect3.y,
					"f, ",
					this.end_vect3.z,
					"f), ",
					base.getEaseString(codeLanguage),
					"));"
				});
			}
			if (this.valueType == 6)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, AMTween.Hash(\"delay\", ",
					base.getWaitTime(frameRate, 0f),
					"f, \"time\", ",
					this.getTime(frameRate),
					"f, \"",
					text,
					"\", obj.memberinfo, \"from\", new Color(",
					this.start_color.r,
					"f, ",
					this.start_color.g,
					"f, ",
					this.start_color.b,
					"f, ",
					this.start_color.a,
					"f), \"to\", new Color(",
					this.end_color.r,
					"f, ",
					this.end_color.g,
					"f, ",
					this.end_color.b,
					"f, ",
					this.end_color.a,
					"f), ",
					base.getEaseString(codeLanguage),
					"));"
				});
			}
			if (this.valueType == 7)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, AMTween.Hash(\"delay\", ",
					base.getWaitTime(frameRate, 0f),
					"f, \"time\", ",
					this.getTime(frameRate),
					"f, \"",
					text,
					"\", obj.memberinfo, \"from\", new Rect(",
					this.start_rect.x,
					"f, ",
					this.start_rect.y,
					"f, ",
					this.start_rect.width,
					"f, ",
					this.start_rect.height,
					"f), \"to\", new Rect(",
					this.end_rect.x,
					"f, ",
					this.end_rect.y,
					"f, ",
					this.end_rect.width,
					"f, ",
					this.end_rect.height,
					"f), ",
					base.getEaseString(codeLanguage),
					"));"
				});
			}
			return "( Error: ValueType " + this.valueType + " not found )";
		}
		else
		{
			if (this.valueType == 8)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, {\"delay\": ",
					base.getWaitTime(frameRate, 0f),
					", \"time\": ",
					this.getTime(frameRate),
					", \"",
					text,
					"\": obj.memberinfo, \"methodtype\": \"morph\", \"from\": ",
					this.getFloatArrayString(codeLanguage, this.start_morph),
					", \"to\": ",
					this.getFloatArrayString(codeLanguage, this.end_morph),
					", ",
					base.getEaseString(codeLanguage),
					"));"
				});
			}
			if (AMPropertyTrack.isValueTypeNumeric(this.valueType))
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, {\"delay\": ",
					base.getWaitTime(frameRate, 0f),
					", \"time\": ",
					this.getTime(frameRate),
					", \"",
					text,
					"\": obj.memberinfo, \"from\": ",
					this.start_val,
					",\"to\": ",
					this.end_val,
					", ",
					base.getEaseString(codeLanguage),
					"});"
				});
			}
			if (this.valueType == 4)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, {\"delay\": ",
					base.getWaitTime(frameRate, 0f),
					", \"time\": ",
					this.getTime(frameRate),
					", \"",
					text,
					"\": obj.memberinfo, \"from\": Vector2(",
					this.start_vect2.x,
					", ",
					this.start_vect2.y,
					"), \"to\": Vector2(",
					this.end_vect2.x,
					", ",
					this.end_vect2.y,
					"), ",
					base.getEaseString(codeLanguage),
					"});"
				});
			}
			if (this.valueType == 5)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, {\"delay\": ",
					base.getWaitTime(frameRate, 0f),
					", \"time\": ",
					this.getTime(frameRate),
					", \"",
					text,
					"\": obj.memberinfo, \"from\": Vector3(",
					this.start_vect3.x,
					", ",
					this.start_vect3.y,
					", ",
					this.start_vect3.z,
					"), \"to\": Vector3(",
					this.end_vect3.x,
					", ",
					this.end_vect3.y,
					", ",
					this.end_vect3.z,
					"), ",
					base.getEaseString(codeLanguage),
					"});"
				});
			}
			if (this.valueType == 6)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, {\"delay\": ",
					base.getWaitTime(frameRate, 0f),
					", \"time\": ",
					this.getTime(frameRate),
					", \"",
					text,
					"\": obj.memberinfo, \"from\": Color(",
					this.start_color.r,
					", ",
					this.start_color.g,
					", ",
					this.start_color.b,
					", ",
					this.start_color.a,
					"), \"to\": Color(",
					this.end_color.r,
					", ",
					this.end_color.g,
					", ",
					this.end_color.b,
					", ",
					this.end_color.a,
					"), ",
					base.getEaseString(codeLanguage),
					"});"
				});
			}
			if (this.valueType == 7)
			{
				return string.Concat(new object[]
				{
					"AMTween.PropertyTo(obj.gameObject, {\"delay\": ",
					base.getWaitTime(frameRate, 0f),
					", \"time\": ",
					this.getTime(frameRate),
					", \"",
					text,
					"\": obj.memberinfo, \"from\": Rect(",
					this.start_rect.x,
					", ",
					this.start_rect.y,
					", ",
					this.start_rect.width,
					", ",
					this.start_rect.height,
					"), \"to\": Rect(",
					this.end_rect.x,
					", ",
					this.end_rect.y,
					", ",
					this.end_rect.width,
					", ",
					this.end_rect.height,
					"), ",
					base.getEaseString(codeLanguage),
					"});"
				});
			}
			return "( Error: ValueType " + this.valueType + " not found )";
		}
	}

	public override int getNumberOfFrames()
	{
		return this.endFrame - this.startFrame;
	}

	public float getTime(int frameRate)
	{
		return (float)this.getNumberOfFrames() / (float)frameRate;
	}

	public override void execute(int frameRate, float delay, string trackId)
	{
		if (this.targetsAreEqual())
		{
			return;
		}
		if (this.endFrame == -1 || !this.component || (this.fieldInfo == null && this.propertyInfo == null && this.methodInfo == null))
		{
			return;
		}
		if (this.fieldInfo != null)
		{
			if (base.hasCustomEase())
			{
				if (AMPropertyTrack.isValueTypeNumeric(this.valueType))
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_val,
						"to",
						this.end_val,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 4)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 5)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_vect3,
						"to",
						this.end_vect3,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 6)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_color,
						"to",
						this.end_color,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 7)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easecurve",
						base.easeCurve
					}));
				}
			}
			else
			{
				if (AMPropertyTrack.isValueTypeNumeric(this.valueType))
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_val,
						"to",
						this.end_val,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 4)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 5)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_vect3,
						"to",
						this.end_vect3,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 6)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_color,
						"to",
						this.end_color,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 7)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"fieldinfo",
						this.fieldInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
			}
		}
		else if (this.propertyInfo != null)
		{
			if (base.hasCustomEase())
			{
				if (AMPropertyTrack.isValueTypeNumeric(this.valueType))
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_val,
						"to",
						this.end_val,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 4)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 5)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_vect3,
						"to",
						this.end_vect3,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 6)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_color,
						"to",
						this.end_color,
						"easecurve",
						base.easeCurve
					}));
				}
				if (this.valueType == 7)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easecurve",
						base.easeCurve
					}));
				}
			}
			else
			{
				if (AMPropertyTrack.isValueTypeNumeric(this.valueType))
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_val,
						"to",
						this.end_val,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 4)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 5)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_vect3,
						"to",
						this.end_vect3,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 6)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_color,
						"to",
						this.end_color,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
				if (this.valueType == 7)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"propertyinfo",
						this.propertyInfo,
						"from",
						this.start_vect2,
						"to",
						this.end_vect2,
						"easetype",
						(AMTween.EaseType)this.easeType
					}));
				}
			}
		}
		else if (this.methodInfo != null)
		{
			if (base.hasCustomEase())
			{
				if (this.valueType == 8)
				{
					AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
					{
						"trackid",
						trackId,
						"delay",
						base.getWaitTime(frameRate, delay),
						"time",
						this.getTime(frameRate),
						"methodtype",
						"morph",
						"methodinfo",
						this.methodInfo,
						"from",
						this.start_morph.ToArray(),
						"to",
						this.end_morph.ToArray(),
						"easecurve",
						base.easeCurve
					}));
				}
			}
			else if (this.valueType == 8)
			{
				AMTween.PropertyTo(this.component, AMTween.Hash(new object[]
				{
					"trackid",
					trackId,
					"delay",
					base.getWaitTime(frameRate, delay),
					"time",
					this.getTime(frameRate),
					"methodtype",
					"morph",
					"methodinfo",
					this.methodInfo,
					"from",
					this.start_morph.ToArray(),
					"to",
					this.end_morph.ToArray(),
					"easetype",
					(AMTween.EaseType)this.easeType
				}));
			}
		}
		else
		{
			Debug.LogError("Animator: No FieldInfo or PropertyInfo set.");
		}
	}

	public string getName()
	{
		if (this.fieldInfo != null)
		{
			return this.fieldInfo.Name;
		}
		if (this.propertyInfo != null)
		{
			return this.propertyInfo.Name;
		}
		if (this.methodInfo != null && this.valueType == 8)
		{
			return "Morph";
		}
		return "Unknown";
	}

	public string getFloatArrayString(int codeLanguage, List<float> ls)
	{
		string text = string.Empty;
		if (codeLanguage == 0)
		{
			text += "new float[]{";
		}
		else
		{
			text += "[";
		}
		for (int i = 0; i < ls.Count; i++)
		{
			text += ls[i].ToString();
			if (codeLanguage == 0)
			{
				text += "f";
			}
			if (i < ls.Count - 1)
			{
				text += ", ";
			}
		}
		if (codeLanguage == 0)
		{
			text += "}";
		}
		else
		{
			text += "]";
		}
		return text;
	}

	public string getValueString(bool brief)
	{
		string text = string.Empty;
		if (AMPropertyTrack.isValueTypeNumeric(this.valueType))
		{
			text += this.formatNumeric(this.start_val);
			if (!brief && this.endFrame != -1)
			{
				text = text + " -> " + this.formatNumeric(this.end_val);
			}
		}
		else if (this.valueType == 4)
		{
			text += this.start_vect2.ToString();
			if (!brief && this.endFrame != -1)
			{
				text = text + " -> " + this.end_vect2.ToString();
			}
		}
		else if (this.valueType == 5)
		{
			text += this.start_vect3.ToString();
			if (!brief && this.endFrame != -1)
			{
				text = text + " -> " + this.end_vect3.ToString();
			}
		}
		else if (this.valueType == 6)
		{
			text += this.start_color.ToString();
			if (!brief && this.endFrame != -1)
			{
				text = text + " -> " + this.end_color.ToString();
			}
		}
		else if (this.valueType == 7)
		{
			text += this.start_rect.ToString();
			if (!brief && this.endFrame != -1)
			{
				text = text + " -> " + this.end_rect.ToString();
			}
		}
		return text;
	}

	private string formatNumeric(float input)
	{
		double num = (double)((input >= 0f) ? input : (input * -1f));
		if (num >= 1.0)
		{
			return input.ToString("N2");
		}
		if (num >= 0.009999999776482582)
		{
			return input.ToString("N3");
		}
		if (num >= 0.0010000000474974513)
		{
			return input.ToString("N4");
		}
		if (num >= 9.999999747378752E-05)
		{
			return input.ToString("N5");
		}
		if (num >= 9.999999747378752E-06)
		{
			return input.ToString("N6");
		}
		return input.ToString();
	}

	private string formatNumeric(double input)
	{
		double num = (input >= 0.0) ? input : (input * -1.0);
		if (num >= 1.0)
		{
			return input.ToString("N2");
		}
		if (num >= 0.01)
		{
			return input.ToString("N3");
		}
		if (num >= 0.001)
		{
			return input.ToString("N4");
		}
		if (num >= 0.0001)
		{
			return input.ToString("N5");
		}
		if (num >= 1E-05)
		{
			return input.ToString("N6");
		}
		return input.ToString();
	}

	public int getStartMorphNameIndex(int numChannels)
	{
		return this.getMorphNameIndex(this.start_morph, numChannels);
	}

	public int getEndMorphNameIndex(int numChannels)
	{
		return this.getMorphNameIndex(this.end_morph, numChannels);
	}

	private int getMorphNameIndex(List<float> morph, int count)
	{
		int num = -1;
		bool flag = true;
		if (morph.Count < count)
		{
			count = morph.Count;
		}
		for (int i = 0; i < count; i++)
		{
			if (flag && morph[i] != 0f)
			{
				flag = false;
			}
			if (morph[i] > 0f && morph[i] < 100f)
			{
				num = -1;
				break;
			}
			if (morph[i] == 100f)
			{
				if (num != -1)
				{
					num = -1;
					break;
				}
				num = i;
			}
		}
		if (flag)
		{
			num = -2;
		}
		return num;
	}

	public bool targetsAreEqual()
	{
		if (this.valueType == 0 || this.valueType == 1 || this.valueType == 2 || this.valueType == 3)
		{
			return this.start_val == this.end_val;
		}
		if (this.valueType == 4)
		{
			return this.start_vect2 == this.end_vect2;
		}
		if (this.valueType == 5)
		{
			return this.start_vect3 == this.end_vect3;
		}
		if (this.valueType == 6)
		{
			return this.start_color == this.end_color;
		}
		if (this.valueType == 7)
		{
			return this.start_rect == this.end_rect;
		}
		if (this.valueType != 8)
		{
			Debug.LogError("Animator: Invalid ValueType " + this.valueType);
			return false;
		}
		if (this.start_morph == null || this.end_morph == null)
		{
			return false;
		}
		for (int i = 0; i < this.start_morph.Count; i++)
		{
			if (this.end_morph.Count <= i || this.start_morph[i] != this.end_morph[i])
			{
				return false;
			}
		}
		return true;
	}

	public object getStartValue()
	{
		if (this.valueType == 0)
		{
			return Convert.ToInt32(this.start_val);
		}
		if (this.valueType == 1)
		{
			return Convert.ToInt64(this.start_val);
		}
		if (this.valueType == 2)
		{
			return Convert.ToSingle(this.start_val);
		}
		if (this.valueType == 3)
		{
			return this.start_val;
		}
		if (this.valueType == 4)
		{
			return this.start_vect2;
		}
		if (this.valueType == 5)
		{
			return this.start_vect3;
		}
		if (this.valueType == 6)
		{
			return this.start_color;
		}
		if (this.valueType == 7)
		{
			return this.start_rect;
		}
		return "Unknown";
	}

	public object getEndValue()
	{
		if (this.valueType == 0)
		{
			return Convert.ToInt32(this.end_val);
		}
		if (this.valueType == 1)
		{
			return Convert.ToInt64(this.end_val);
		}
		if (this.valueType == 2)
		{
			return Convert.ToSingle(this.end_val);
		}
		if (this.valueType == 3)
		{
			return this.end_val;
		}
		if (this.valueType == 4)
		{
			return this.end_vect2;
		}
		if (this.valueType == 5)
		{
			return this.end_vect3;
		}
		if (this.valueType == 6)
		{
			return this.end_color;
		}
		if (this.valueType == 7)
		{
			return this.end_rect;
		}
		return "Unknown";
	}

	public override AnimatorTimeline.JSONAction getJSONAction(int frameRate)
	{
		if (this.targetsAreEqual())
		{
			return null;
		}
		if (this.endFrame == -1 || !this.component || (this.fieldInfo == null && this.propertyInfo == null && this.methodInfo == null))
		{
			return null;
		}
		AnimatorTimeline.JSONAction jsonaction = new AnimatorTimeline.JSONAction();
		jsonaction.method = "propertyto";
		jsonaction.go = this.component.gameObject.name;
		jsonaction.delay = base.getWaitTime(frameRate, 0f);
		jsonaction.time = this.getTime(frameRate);
		List<string> list = new List<string>();
		list.Add(this.component.GetType().Name);
		if (this.fieldInfo != null || this.propertyInfo != null)
		{
			if (this.valueType == 0)
			{
				list.Add("integer");
				jsonaction.ints = new int[]
				{
					Convert.ToInt32(this.start_val),
					Convert.ToInt32(this.end_val)
				};
			}
			else if (this.valueType == 1)
			{
				list.Add("long");
				jsonaction.longs = new long[]
				{
					Convert.ToInt64(this.start_val),
					Convert.ToInt64(this.end_val)
				};
			}
			else if (this.valueType == 2)
			{
				list.Add("float");
				jsonaction.floats = new float[]
				{
					Convert.ToSingle(this.start_val),
					Convert.ToSingle(this.end_val)
				};
			}
			else if (this.valueType == 3)
			{
				list.Add("double");
				jsonaction.doubles = new double[]
				{
					this.start_val,
					this.end_val
				};
			}
			else if (this.valueType == 4)
			{
				list.Add("vector2");
				AnimatorTimeline.JSONVector2 jsonvector = new AnimatorTimeline.JSONVector2();
				jsonvector.setValue(this.start_vect2);
				AnimatorTimeline.JSONVector2 jsonvector2 = new AnimatorTimeline.JSONVector2();
				jsonvector2.setValue(this.end_vect2);
				jsonaction.vect2s = new AnimatorTimeline.JSONVector2[]
				{
					jsonvector,
					jsonvector2
				};
			}
			else if (this.valueType == 5)
			{
				list.Add("vector3");
				jsonaction.setPath(new Vector3[]
				{
					this.start_vect3,
					this.end_vect3
				});
			}
			else if (this.valueType == 6)
			{
				list.Add("color");
				AnimatorTimeline.JSONColor jsoncolor = new AnimatorTimeline.JSONColor();
				jsoncolor.setValue(this.start_color);
				AnimatorTimeline.JSONColor jsoncolor2 = new AnimatorTimeline.JSONColor();
				jsoncolor2.setValue(this.end_color);
				jsonaction.colors = new AnimatorTimeline.JSONColor[]
				{
					jsoncolor,
					jsoncolor2
				};
			}
			else if (this.valueType == 7)
			{
				list.Add("rect");
				AnimatorTimeline.JSONRect jsonrect = new AnimatorTimeline.JSONRect();
				jsonrect.setValue(this.start_rect);
				AnimatorTimeline.JSONRect jsonrect2 = new AnimatorTimeline.JSONRect();
				jsonrect2.setValue(this.end_rect);
				jsonaction.rects = new AnimatorTimeline.JSONRect[]
				{
					jsonrect,
					jsonrect2
				};
			}
			if (this.fieldInfo != null)
			{
				list.Add("fieldinfo");
				list.Add(this.fieldInfo.Name);
			}
			else
			{
				list.Add("propertyinfo");
				list.Add(this.propertyInfo.Name);
			}
		}
		else if (this.methodInfo != null && this.valueType == 8)
		{
			list.Add("morph");
			jsonaction.floats = this.start_morph.ToArray();
			jsonaction.floatsExtra = this.end_morph.ToArray();
		}
		base.setupJSONActionEase(jsonaction);
		jsonaction.strings = list.ToArray();
		return jsonaction;
	}

	public int valueType;

	public Component component;

	public string componentName;

	public int endFrame;

	public string propertyName;

	public string fieldName;

	public string methodName;

	public string[] methodParameterTypes;

	private MethodInfo cachedMethodInfo;

	private PropertyInfo cachedPropertyInfo;

	private FieldInfo cachedFieldInfo;

	public double start_val;

	public Vector2 start_vect2;

	public Vector3 start_vect3;

	public Color start_color;

	public Rect start_rect;

	public double end_val;

	public Vector2 end_vect2;

	public Vector3 end_vect3;

	public Color end_color;

	public Rect end_rect;

	public List<float> start_morph;

	public List<float> end_morph;
}