public void SetExpression(Pig.Expressions exp)
{
if (this.m_currentExpression != exp)
{
AudioSource[] array = null;
switch (exp)
{
case Pig.Expressions.Fear:
array = this.FearAudio;
break;
case Pig.Expressions.Hit:
array = this.HitAudio;
break;
}
string text = this.ExpressionToAnimationName(exp);
if (!string.IsNullOrEmpty(text))
{
this.m_faceAnimation.Play(text);
}
if (array != null && array.Length > 0)
{
if (this.m_currentSound)
{
this.m_currentSound.Stop();
}
this.m_currentSound = Singleton <AudioManager> .Instance.SpawnOneShotEffect(array, base.transform);
}
this.m_expressionSetTime = Time.time;
this.m_currentExpression = exp;
}
}
private Pig.Expressions SelectExpression()
{
Vector3 velocity = base.rigidbody.velocity;
Pig.Expressions result = Pig.Expressions.Normal;
if (Time.time > this.m_expressionSetTime + 1f)
{
float num = velocity.magnitude + 0.3f * Mathf.Abs(velocity.y);
if (num > this.speedFunThreshold)
{
result = Pig.Expressions.Grin;
}
if (num > 0.5f * (this.speedFunThreshold + this.speedFearThreshold))
{
result = Pig.Expressions.FearfulGrin;
}
if (num > this.speedFearThreshold)
{
result = Pig.Expressions.Fear;
}
if (Time.time - base.contraption.GetGroundTouchTime(base.ConnectedComponent) > 0.25f)
{
float num2 = -velocity.y;
if (num2 > this.fallFearThreshold)
{
result = Pig.Expressions.Fear2;
}
}
}
else
{
result = this.m_currentExpression;
}
return(result);
}
private void PlayKingPigExpressionAudioEffect(Pig.Expressions expr)
{
if (this.m_LastExpressionSound)
{
if (this.m_LastAudioExpression == expr)
{
return;
}
if (this.m_LastAudioExpression == Pig.Expressions.WaitForFood)
{
this.m_LastExpressionSound.Stop();
}
}
PigExpressionSound pigExpressionSound = null;
foreach (PigExpressionSound x in this.expressionSounds)
{
if (x.expression == expr)
{
pigExpressionSound = x;
break;
}
}
if (pigExpressionSound != null && pigExpressionSound.soundFx != null && pigExpressionSound.soundFx.Length > 0)
{
AudioSource effectSource = pigExpressionSound.soundFx[UnityEngine.Random.Range(0, pigExpressionSound.soundFx.Length)];
this.m_LastExpressionSound = Singleton <AudioManager> .Instance.Play2dEffect(effectSource);
this.m_LastAudioExpression = expr;
}
}
public IEnumerator PlayAnimation(Pig.Expressions exp, float time)
{
this.m_isPlayingAnimation = true;
this.SetExpression(exp);
yield return(new WaitForSeconds(time));
this.m_isPlayingAnimation = false;
yield break;
}
private IEnumerator AnimationCoroutine(Pig.Expressions exp, float time)
{
this.m_isPlayingAnimation = true;
this.SetExpression(exp);
yield return(new WaitForSeconds(time));
this.SetExpression(Pig.Expressions.Normal);
this.m_isPlayingAnimation = false;
yield break;
}
private IEnumerator PlayIdleAnim()
{
KingPig kp = this.m_kingPig.GetComponent <KingPig>();
Pig.Expressions idleExp = this.m_IdleExpressions[UnityEngine.Random.Range(0, this.m_IdleExpressions.Length)];
this.PlayKingPigExpressionAudioEffect(idleExp);
yield return(base.StartCoroutine(kp.PlayAnimation(idleExp)));
kp.SetExpression(this.m_defaultExpression);
yield break;
}
public IEnumerator PlayAnimation(Pig.Expressions exp)
{
string animName = this.ExpressionToAnimationName(exp);
if (!string.IsNullOrEmpty(animName))
{
SpriteAnimation.Animation anim = this.m_faceAnimation.GetAnimation(animName);
float time = anim.frames[anim.frames.Count - 1].endTime;
this.m_isPlayingAnimation = true;
this.SetExpression(exp);
yield return(new WaitForSeconds(time));
this.m_isPlayingAnimation = false;
}
yield break;
}
private string ExpressionToAnimationName(Pig.Expressions exp)
{
switch (exp)
{
case Pig.Expressions.Normal:
return("Normal");
case Pig.Expressions.Laugh:
return("Laugh");
case Pig.Expressions.Fear:
return("Fear_1");
case Pig.Expressions.Hit:
return("Hit");
case Pig.Expressions.Blink:
return("Blink");
case Pig.Expressions.Chew:
return("Chew");
case Pig.Expressions.WaitForFood:
return("WaitForFood");
case Pig.Expressions.Burp:
return("Burp");
case Pig.Expressions.Snooze:
return("Snooze");
case Pig.Expressions.Panting:
return("Panting");
}
return(null);
}
private Pig.Expressions SelectExpression()
{
Vector3 velocity = base.rigidbody.velocity;
Pig.Expressions result = Pig.Expressions.Normal;
if (Time.time > this.m_expressionSetTime + 1f)
{
float num = velocity.magnitude + 0.3f * Mathf.Abs(velocity.y);
if (num > this.speedFearThreshold)
{
result = Pig.Expressions.Fear;
}
float num2 = -velocity.y;
if (num2 > this.fallFearThreshold)
{
result = Pig.Expressions.Fear;
}
}
else
{
result = this.m_currentExpression;
}
return(result);
}
public void PlayAnimation(Pig.Expressions exp, float time)
{
base.StartCoroutine(this.AnimationCoroutine(exp, time));
}
public void SetExpression(Pig.Expressions exp)
{
if (this.m_currentExpression != exp)
{
switch (exp)
{
case Pig.Expressions.Normal:
this.m_faceAnimation.Play("Normal");
break;
case Pig.Expressions.Laugh:
this.m_faceAnimation.Play("Laugh");
break;
case Pig.Expressions.Grin:
this.m_faceAnimation.Play("Grin");
break;
case Pig.Expressions.Fear:
this.m_faceAnimation.Play("Fear_1");
break;
case Pig.Expressions.Fear2:
this.m_faceAnimation.Play("Fear_2");
break;
case Pig.Expressions.Hit:
this.m_faceAnimation.Play("Hit");
break;
case Pig.Expressions.Blink:
this.m_faceAnimation.Play("Blink");
break;
case Pig.Expressions.FearfulGrin:
this.m_faceAnimation.Play("FearfulGrin");
break;
}
if (Singleton <GameManager> .Instance.IsInGame() && WPFMonoBehaviour.levelManager != null && WPFMonoBehaviour.levelManager.gameState != LevelManager.GameState.Building)
{
AudioSource[] sound = this.m_expressions[(int)exp].sound;
if (sound != null && sound.Length > 0)
{
for (int i = 0; i < sound.Length; i++)
{
sound[i].pitch = this.m_pitch;
}
if (this.m_currentSound)
{
this.m_currentSound.Stop();
}
this.m_currentSound = ((!this.m_isSilent) ? Singleton <AudioManager> .Instance.SpawnOneShotEffect(sound, base.transform) : null);
if (this.m_chorusFilter)
{
AudioChorusFilter audioChorusFilter = this.m_currentSound.gameObject.AddComponent <AudioChorusFilter>();
audioChorusFilter.dryMix = this.m_chorusFilter.dryMix;
audioChorusFilter.wetMix1 = this.m_chorusFilter.wetMix1;
audioChorusFilter.wetMix2 = this.m_chorusFilter.wetMix2;
audioChorusFilter.wetMix3 = this.m_chorusFilter.wetMix3;
audioChorusFilter.delay = this.m_chorusFilter.delay;
audioChorusFilter.rate = this.m_chorusFilter.rate;
audioChorusFilter.depth = this.m_chorusFilter.depth;
}
if (this.m_distortionFilter)
{
AudioDistortionFilter audioDistortionFilter = this.m_currentSound.gameObject.AddComponent <AudioDistortionFilter>();
audioDistortionFilter.distortionLevel = this.m_distortionFilter.distortionLevel;
}
if (this.m_echoFilter)
{
AudioEchoFilter audioEchoFilter = this.m_currentSound.gameObject.AddComponent <AudioEchoFilter>();
audioEchoFilter.delay = this.m_echoFilter.delay;
audioEchoFilter.decayRatio = this.m_echoFilter.decayRatio;
audioEchoFilter.wetMix = this.m_echoFilter.wetMix;
audioEchoFilter.dryMix = this.m_echoFilter.dryMix;
}
if (this.m_hpFilter)
{
AudioHighPassFilter audioHighPassFilter = this.m_currentSound.gameObject.AddComponent <AudioHighPassFilter>();
audioHighPassFilter.cutoffFrequency = this.m_hpFilter.cutoffFrequency;
audioHighPassFilter.highpassResonanceQ = this.m_hpFilter.highpassResonanceQ;
}
if (this.m_lpFilter)
{
AudioLowPassFilter audioLowPassFilter = this.m_currentSound.gameObject.AddComponent <AudioLowPassFilter>();
audioLowPassFilter.cutoffFrequency = this.m_lpFilter.cutoffFrequency;
audioLowPassFilter.lowpassResonanceQ = this.m_lpFilter.lowpassResonanceQ;
}
if (this.m_reverbFilter)
{
AudioReverbFilter audioReverbFilter = this.m_currentSound.gameObject.AddComponent <AudioReverbFilter>();
if (this.m_reverbFilter.reverbPreset == AudioReverbPreset.User)
{
audioReverbFilter.dryLevel = this.m_reverbFilter.dryLevel;
audioReverbFilter.room = this.m_reverbFilter.room;
audioReverbFilter.roomHF = this.m_reverbFilter.roomHF;
audioReverbFilter.roomLF = this.m_reverbFilter.roomLF;
audioReverbFilter.decayTime = this.m_reverbFilter.decayTime;
audioReverbFilter.decayHFRatio = this.m_reverbFilter.decayHFRatio;
audioReverbFilter.reflectionsLevel = this.m_reverbFilter.reflectionsLevel;
audioReverbFilter.reflectionsDelay = this.m_reverbFilter.reflectionsDelay;
audioReverbFilter.hfReference = this.m_reverbFilter.hfReference;
audioReverbFilter.lfReference = this.m_reverbFilter.lfReference;
audioReverbFilter.diffusion = this.m_reverbFilter.diffusion;
audioReverbFilter.density = this.m_reverbFilter.density;
}
else
{
audioReverbFilter.reverbPreset = this.m_reverbFilter.reverbPreset;
}
}
}
}
this.m_expressionSetTime = Time.time;
this.m_currentExpression = exp;
}
}
private void Update()
{
this.UpdateBuildModeAnimations();
float x = 0.2f * Mathf.PerlinNoise(0.75f * Time.time, 0f) - 0.1f;
float y = 0.2f * Mathf.PerlinNoise(0f, 0.75f * Time.time) - 0.1f;
this.m_faceRotation.SetTargetDirection(this.m_lookDirection + new Vector2(x, y));
this.m_blinkTimer -= Time.deltaTime;
bool flag = false;
if (this.m_blinkTimer <= 0f && this.m_currentExpression == Pig.Expressions.Normal)
{
this.m_faceAnimation.Play("Blink");
if (this.m_playerIsDraggingPart)
{
this.m_pupilMover.transform.localPosition = 0.035f * this.m_lookTargetDirection;
}
else
{
this.m_pupilMover.transform.localPosition = 0.04f * UnityEngine.Random.insideUnitCircle;
}
this.m_blinkTimer = UnityEngine.Random.Range(1.5f, 4f);
flag = true;
}
this.m_playerIsDraggingPart = false;
if (!base.contraption || !base.contraption.IsRunning)
{
return;
}
if (base.enclosedInto == null)
{
this.m_rolledDistance += base.rigidbody.velocity.magnitude * Time.deltaTime;
}
else
{
this.m_traveledDistance += base.rigidbody.velocity.magnitude * Time.deltaTime;
}
this.m_currentMagnitude = base.rigidbody.velocity.magnitude;
if (Mathf.Abs(this.m_currentMagnitude - this.m_previousMagnitude) > 5f && !this.m_isPlayingAnimation)
{
this.PlayAnimation(Pig.Expressions.Hit, 1f);
this.starsLoop.Play();
this.m_starsTimer = 4f;
this.m_previousMagnitude = this.m_currentMagnitude;
return;
}
this.m_previousMagnitude = this.m_currentMagnitude;
if (!this.m_isPlayingAnimation)
{
Pig.Expressions expression = this.SelectExpression();
if (!flag)
{
this.SetExpression(expression);
}
}
if (!base.contraption.HasComponentEngine(base.ConnectedComponent) && base.contraption.HasPoweredPartsRunning(base.ConnectedComponent))
{
this.PlayWorkingAnimation();
if (!this.sweatLoop.isPlaying)
{
this.sweatLoop.Play();
}
}
else
{
if (this.sweatLoop.isPlaying)
{
this.sweatLoop.Stop();
}
if (this.m_visualizationPart.localScale.x > 1.001f || this.m_visualizationPart.localScale.y > 1.001f || this.m_visualizationPart.localPosition.y > 0.001f)
{
this.m_visualizationPart.localScale = 0.9f * this.m_visualizationPart.localScale + 0.1f * Vector3.one;
this.m_visualizationPart.localPosition = 0.9f * this.m_visualizationPart.localPosition + 0.1f * Vector3.zero;
this.m_workingTime = 0.5f;
}
}
if (this.starsLoop.isPlaying)
{
if (this.m_starsTimer > 0f)
{
float num = this.m_starsTimer;
if (this.m_starsTimer > 2f)
{
num *= 2f;
}
this.m_starsTimer -= Time.deltaTime;
}
else
{
this.starsLoop.Stop();
}
}
if (!this.m_replayPulseDone && Singleton <GameManager> .Instance.IsInGame())
{
this.CheckStopped();
}
if (!this.m_faceZFlattened && !base.GetComponent <Joint>())
{
this.m_faceRotation.ScaleFaceZ(0.01f);
this.m_faceZFlattened = true;
}
}
private void Update()
{
if (this.m_faceRotation)
{
Vector3 targetDirection = Vector3.zero;
if (this.followMouse)
{
Vector3 a;
if (GameObject.FindGameObjectWithTag("MainCamera"))
{
a = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>().ScreenToWorldPoint(Input.mousePosition);
}
else
{
a = GameObject.FindGameObjectWithTag("HUDCamera").GetComponent <Camera>().ScreenToWorldPoint(Input.mousePosition);
}
targetDirection = a - base.transform.position;
targetDirection.z = 0f;
}
else
{
float num = Mathf.Pow(Mathf.Clamp(Mathf.PerlinNoise(0.6f * Time.time, -1.5234f), 0f, 1f), 1.5f);
this.m_phase += num * Time.deltaTime;
float num2 = Mathf.PerlinNoise(this.m_phase, 0.123f);
float num3 = Mathf.PerlinNoise(this.m_phase, 5.9123f);
targetDirection = new Vector3(2f * num2 - 1f, 2f * num3 - 1f, 0f);
targetDirection = Mathf.Pow(targetDirection.magnitude, 1.2f) * targetDirection.normalized;
}
this.m_faceRotation.SetTargetDirection(targetDirection);
}
if (!this.m_isPlayingAnimation)
{
this.m_blinkTimer -= Time.deltaTime;
bool flag = false;
if (this.m_blinkTimer <= 0f && this.m_currentExpression == Pig.Expressions.Normal)
{
this.m_faceAnimation.Play("Blink");
this.m_pupilMover.transform.localPosition = 0.05f * UnityEngine.Random.insideUnitCircle;
this.m_blinkTimer = UnityEngine.Random.Range(2.5f, 5f);
flag = true;
}
if (!base.contraption || !base.contraption.IsRunning)
{
return;
}
Pig.Expressions expression = this.SelectExpression();
if (!flag)
{
this.SetExpression(expression);
}
}
if (this.starsLoop.isPlaying)
{
if (this.m_starsTimer > 0f)
{
float num4 = this.m_starsTimer;
if (this.m_starsTimer > 2f)
{
num4 *= 2f;
}
this.m_starsTimer -= Time.deltaTime;
}
else
{
this.starsLoop.Stop();
}
}
if (!this.m_faceZFlattened && !base.GetComponent <Joint>())
{
this.m_faceRotation.ScaleFaceZ(0.01f);
this.m_faceZFlattened = true;
}
}
public void PlayEatingAnimation(Pig.Expressions expr, float time, Pig.Expressions normalExpression)
{
base.StartCoroutine(this.PlayEatingAnimationCoroutine(expr, 1f, normalExpression));
}
