public float playOpenCrateAnim(Vector3 cratePos)
{
headingOverride = transform.position - cratePos;
currentState = AnimState.OpeningCrate;
playerModel.animation.CrossFade("OpenCrate", 0.05f, PlayMode.StopSameLayer);
return playerModel.animation["OpenCrate"].length;
}
public void onAnimationStatusChanged(AnimState state)
{
if (state == AnimState.STOPPED_END && HighLogic.LoadedSceneIsFlight)
{
engineModule.Activate();
}
}
public float playHackServerAnim(Vector3 serverPos)
{
headingOverride = transform.position - serverPos;
currentState = AnimState.HackingServer;
playerModel.animation.CrossFade("HackServer", 0.05f, PlayMode.StopSameLayer);
return playerModel.animation["HackServer"].length;
}
public TimBehavior()
: base("TimBehavior")
{
this.direction = NONE;
this.anim2D = null;
this.trans2D = null;
this.currentState = AnimState.Idle;
}
void GotHurt()
{
animState = AnimState.HURT;
animation.Stop();
animation.clip = animClip[(int)animState];
animation.Play();
StartCoroutine("GetBackToRunning");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="content"></param>
/// <param name="asset"></param>
/// <param name="mass"></param>
public Player(ContentManager content, String asset, float mass)
: base(content, asset, mass)
{
_animState = AnimState.IDLE;
_score = 0;
_tail = new Entity(content, "Characters/tail_yellow");
_tail.Scale = 0;
}
// Use this for initialization
void Start()
{
CurrentState = AnimState.idle;
animation.AddClip(Idle,"idle");
animation.AddClip(Run,"running");
animation.AddClip(Attack, "attack");
animation.AddClip(Skill, "skill");
animation.CrossFade("idle");
}
void Idle()
{
if(!animation.isPlaying)
{
animState = AnimState.RUNNING;
animation.Stop();
animation.clip = animClip[(int)animState];
}
}
void AnimationChange(AnimState newState)
{
if (newState == currentAnim)
return;
else
{
// Debug.Log(newState.ToString());
currentAnim = newState;
animator.SetTrigger(currentAnim.ToString());
}
}
void Update()
{
if (_networkView.isMine)
{
if( Input.GetMouseButtonDown(0) )
{
if (isDie)
return;
Fire();
_networkView.RPC("Fire", RPCMode.Others);
}
Vector3 localVelocity = tr.InverseTransformDirection(controller.velocity);
Vector3 forwardDir = new Vector3(0f, 0f, localVelocity.z);
Vector3 rigthDir = new Vector3(localVelocity.x, 0f, 0f);
if( forwardDir.z >= 0.1f )
{
animState = AnimState.runForwad;
}
else if( forwardDir.z <= -1.0f)
{
animState = AnimState.runBackward;
}
else if (rigthDir.x >= 0.1f)
{
animState = AnimState.runRight;
}
else if (rigthDir.x <= -0.1f)
{
animState = AnimState.runLeft;
}
else
{
animState = AnimState.idle;
}
anim.CrossFade(animClips[(int)animState].name, 0.2f);
}
else
{
if( Vector3.Distance(tr.position, currPos)>=2.0f)
{
tr.position = currPos;
tr.rotation = currRot;
}
else
{
tr.position = Vector3.Lerp(tr.position, currPos, Time.deltaTime * 10.0f);
tr.rotation = Quaternion.Slerp(tr.rotation, currRot, Time.deltaTime * 10.0f);
}
anim.CrossFade(animClips[(int)animState].name, 0.1f);
}
}
public void restorePreviousAnimationState(AnimState state)
{
if (state == AnimState.PLAYING_BACKWARD)
{
state = AnimState.STOPPED_START;
}
else if (state == AnimState.PLAYING_FORWARD)
{
state = AnimState.STOPPED_END;
}
setAnimState(state, false);
}
public void deployEngineEvent()
{
AnimState state = animationControl.getAnimationState();
if (state != AnimState.STOPPED_END)
{
setAnimationState(AnimState.PLAYING_FORWARD);
}
else
{
engineModule.Activate();
}
setupGuiFields(animationControl.getAnimationState(), engineModule.EngineIgnited);
}
/// <summary>
/// FSM中调用状态的每帧更新.
/// </summary>
public void Update()
{
// 当前状态执行完成时
if (CurrentAnimState.IsFinished())
{
// 禁用当前状态
CurrentAnimState.OnDeactivate();
// 切换到默认状态
CurrentAnimState = DefaultAnimState;
CurrentAnimState.OnActivate(null);
}
CurrentAnimState.Update();
}
protected void SwitchToNewStage(AgentAction action)
{
if (NextAnimState != null)
{
CurrentAnimState.Release();
CurrentAnimState.OnDeactivate();
CurrentAnimState = NextAnimState;
CurrentAnimState.OnActivate(action);
NextAnimState = null;
}
}
// Update is called once per frame
private void Update()
{
if (animState == null)
{
animState = this.GetComponent <AnimState>();
return;
}
if (animState.ANIMSTATE == AnimState.ANIM_STATE.ATTACK)
{
return;
}
isBishop = true;
if (isEnemyFront(Vector2.left))
{ // 사거리안 앞에 적이 있고
isBishop = false;
if (isCoolTime)
{ // 쿨타임중이면
CoolTimeTikTok();
animState.ChangeAnimState(0);
}
else if (FindAllyInFront())
{ // 힐을 받을 아군이있다면
animState.ChangeAnimState(2);
}
else
{
animState.ChangeAnimState(0);
}
}
else
{ // 사거리안 앞에 적이 없고
if (isCoolTime)
{ // 쿨타임중이면
CoolTimeTikTok();
animState.ChangeAnimState(0);
}
else if (FindAllyInFront())
{ // 힐을 받을 아군이 있다면
animState.ChangeAnimState(2);
healGO.SetActive(true);
}
else
{
animState.ChangeAnimState(1);
}
}
}
public void AnimCallback(string animId, AnimState animState, System.Object data = null)
{
if ((animState == AnimState.Complete))
{
if (animId == "Jump")
{
AnimationManager.Play(backToGnd, this, 0f, "ToGnd");
}
}
if (animState == AnimState.Update)
{
}
}
/// <summary>
/// Plays an animation within spriter animator.
/// </summary>
/// <param name="state">The state to be executed.</param>
/// <param name="speed">The playback speed.</param>
void SpriterAnimatorPlay(string state)
{
if (IsReady != true)
{
return;
}
AnimState animState = animStateList[currLayerIdx].Find(x => x.Name == state);
Assert.IsNotNull <AnimState>(animState, "The state wasn't found in the given layer! " + state + " (" + currLayerIdx + ")");
spriterAnimator.Speed = animState.PlaybackSpeed;
spriterAnimator.Play(animState.AnimName);
}
private void GoToNextState()
{
frame = 0;
if (state == AnimState.Summon)
{
int amt = 2;
for (int i = 0; i < amt; ++i)
{
for (int t = 0; t < 10; ++t)
{
Vector2 pos = new Vector2(1 + Game1.random.Next((int)World.map.Size.X - 2), 1 + Game1.random.Next((int)World.map.Size.Y - 2));
if (World.map.IsAirSolid(pos.X, pos.Y))
{
continue;
}
World.QueueObject(new BatEnemy(World)
{
Position = new Vector3(pos.X + 0.5f, 0.5f, pos.Y + 0.5f)
});
break;
}
}
Game1.playSound("debuffHit");
state = AnimState.Immune;
}
else if (state != AnimState.Glow)
{
state = AnimState.Glow;
}
else
{
switch (Game1.random.Next(4))
{
case 0:
case 1:
state = AnimState.Glow;
break;
case 2:
state = AnimState.Shoot;
break;
case 3:
state = AnimState.Summon;
break;
}
}
}
/*void Setup (GameObject oldExp = null) {
* BaseSetup ();
* if (oldExp != null) {
* transform.name = sRend.name.Substring (0, sRend.name.Length - 7) + id.ToString ();
* id = oldExp.GetComponent<Experiment> ().id;
* } else {
* id = -1;
* }
* }*/
internal void Update()
{
if (currentAct != null && !currentAct.Update())
{
currentAct = null;
}
switch (state)
{
case ExpState.Moving:
//print ("I am : " + expGroup);
aState = AnimState.Neutral;
if (expGroup == Society.JOINING_GROUP_ID)
{
currentAct = new TeleportToAction(this, society.GetGroupStats(expGroup).GetExpSpot(this));
SetState(ExpState.Editing);
break;
}
if (expGroup == Society.ROGUE_GROUP_ID)
{
currentAct = new MoveToGroupAction(this, society.AvoidGroups(this));
}
else
{
currentAct = new MoveToGroupAction(this, society.GetGroupStats(expGroup).GetExpSpot(this));
}
SetState(ExpState.Pending);
break;
case ExpState.Attacking:
aState = AnimState.Angry;
if (expGroup < Society.NUM_EXTRA_GROUPS)
{
currentAct = new AttackGroupAction(this, society.COMOfGroup(expGroup));
}
else
{
currentAct = new AttackGroupAction(this, society.GetGroupStats(expGroup).center);
}
SetState(ExpState.Pending);
break;
case ExpState.Death:
DestroySelf();
break;
}
UpdateAnimator();
}
/// <summary>
/// scene開始時のアニメ
/// </summary>
private void StartAnime()
{
if (State != AnimState.start)
{
return;
}
else if (count >= 1f)
{
State = AnimState.startEnd;
return;
}
SmashSprite();
InPyramid();
}
public void initializeExternal(SSTUAnimData[] animData)
{
AnimState prevState = (AnimState)Enum.Parse(typeof(AnimState), persistentState);
float time = prevState == AnimState.STOPPED_START || prevState == AnimState.PLAYING_BACKWARD ? 0 : 1;
if (controller != null)
{
controller.clearAnimationData();
controller = null;
}
controller = new AnimationController(time, animationMaxDeploy);
controller.addAnimationData(animData);
controller.restorePreviousAnimationState(prevState, animationMaxDeploy);
controller.setStateChangeCallback(onAnimationStateChange);
}
public void SetAnimState(AnimState s)
{
_animState = s;
switch (s)
{
case AnimState.Normal:
_speed = 5f;
break;
case AnimState.Frightened:
_speed = 10f;
break;
}
}
/// <summary>
/// Setup a trigger for a state.
/// </summary>
/// <param name="layer">The animator layer.</param>
/// <param name="state">The state to setup.</param>
/// <param name="param">The parameter name.</param>
/// <param name="nextState">The next state to go.</param>
public void SpriterAnimatorSetupStateTrigger(int layer, string state, string param, string nextState)
{
Assert.IsTrue(layer >= 0 && layer < spriterLayerAmount, "Invalid layer ID received: " + layer);
AnimState animState = animStateList[layer].Find(x => x.Name == state);
Assert.IsNotNull <AnimState>(animState, "The state wasn't found in the given layer!");
Assert.IsTrue(param.Length > 0, "Invalid trigger parameter name: \"" + param + "\"");
Assert.IsTrue(nextState.Length > 0, "Invalid next state name: \"" + param + "\"");
Assert.IsTrue(animStateList[layer].Exists(x => x.Name == nextState), "The next state doesn't exist in the given layer. Layer: " + layer + " - State: " + nextState);
AnimState.TriggerParam newParam = new AnimState.TriggerParam();
newParam.Name = param;
newParam.NextState = nextState;
animState.TriggerParamsList.Add(newParam);
}
// Start is called before the first frame update
void Start()
{
_currentState = AnimState.Run;
//Reason described in ApplyNewState method
//(-)Expensive (-)Configuration in runtime (+)Changes of AnimState enum won't affect this script
//var list = new List<string>(Enum.GetNames(typeof(AnimState)));
//list.Remove("UNDEFINED");
//_stateNames = list.ToArray();
//_stateNamesLength = _stateNames.Length;
//(+)Cheaper (+)Configuration in compile-time (-)Changes of AnimState enum will affect this script
_stateNames = new string[] { "Run", "Jump", "MidAir", "Fall", "Dash", "DashDown", "HitGround", "HitCeiling", "Die" };
_stateNamesLength = _stateNames.Length;
}
private void onAnimationStateChange(AnimState newState)
{
if (newState == AnimState.STOPPED_START)
{
if (baseArea != null)
{
shieldedAreas.AddUnique(baseArea);
}
}
else if (newState == AnimState.STOPPED_END)
{
shieldedAreas.Remove(baseArea);
}
needsUpdate = true;
}
private void changeState(UIState state)
{
if (m_currentState == UIState.MAINMENU && state == UIState.OPTIONS)
{
m_currAnimState = AnimState.MAINMENU_TO_OPTIONS;
m_currentState = UIState.OPTIONS;
}
else
if ( m_currentState == UIState.OPTIONS && state == UIState.MAINMENU )
{
m_currAnimState = AnimState.OPTIONS_TO_MAINMENU;
m_currentState = UIState.MAINMENU;
}
}
/// <summary>
/// 移动
/// </summary>
/// <param name="point">目标点</param>
public void Move(Vector3 point)
{
if (state == AnimState.DEATH)
{
return;
}
//y不能有变化
point.y = transform.position.y;
//寻路
agent.ResetPath();
agent.SetDestination(point);
//播放动画
animControl.Walk();
state = AnimState.WALK;
}
public void Play(AnimState state)
{
if (OnStatePlay.IsNotNull())
{
OnStatePlay(state);
}
if (CanAnimate)
{
AnimationClip clip = GetStateClip(state);
if (clip.IsNotNull())
{
animator.CrossFade(clip.name);
}
}
}
public ChainPiece(ActorApi api, Vector3 pos, AnimState animState, int distance)
{
this.api = api;
this.distance = distance;
Transform transform = AddComponent <Transform>();
Transform.Pos = pos;
collisionFlags = CollisionFlags.None;
RequestMetadata("Object/MovingPlatform");
SetAnimation(animState);
}
private void setAnimationState(AnimState state)
{
AnimState currentState = animationControl.getAnimationState();
//exceptions below fix issues of OnActive being called by moduleEngine during startup
if (currentState == AnimState.STOPPED_END && state == AnimState.PLAYING_FORWARD)
{
return;
} //don't allow deploying from deployed
else if (currentState == AnimState.STOPPED_START && state == AnimState.PLAYING_BACKWARD)
{
return;
} //don't allow retracting from retracted
animationControl.setToState(state);
}
public void retractEngineEvent()
{
AnimState state = animationControl.getAnimationState();
if (state != AnimState.STOPPED_START)
{
setAnimationState(AnimState.PLAYING_BACKWARD);
engineModule.Shutdown();
}
else
{
engineModule.Shutdown();
}
setupGuiFields(animationControl.getAnimationState(), engineModule.EngineIgnited);
}
//Change state according to id.
public void SetState(StateID id)
{
if (!states.ContainsKey(id))
{
return;
}
if (current != null)
{
current.OnExit();
}
current = states[id];
current.OnEnter();
}
public override void SetAnimationState()
{
if (animator != null && animState != AnimState.Pep)
{
if (isColliding && animState != AnimState.Bump)
{
animator.StopAllAnimations();
animator.Play("bump", restart: true);
animState = AnimState.Bump;
}
else if (isMoving)
{
if (animState == AnimState.Idle)
{
Debug.Log("Play Transition");
animator.Play("transition", restart: true);
animState = AnimState.Transition;
}
else if (animState == AnimState.Bump || (animState == AnimState.Transition && !animator.isPlaying("transition")))
{
Debug.Log("Play Move");
animator.Play("move", restart: true, loop: true);
animState = AnimState.Move;
}
}
else
{
if (animState == AnimState.Move)
{
animator.StopAllAnimations();
animator.Play("transition", reverse: true, restart: true);
Debug.Log("Play End Transition");
animState = AnimState.Transition;
}
else if (animState == AnimState.Transition && !animator.isPlaying("transition"))
{
Debug.Log("Play Idle");
animator.Play("idle", restart: true, loop: true);
animState = AnimState.Idle;
}
else if (animState == AnimState.Bump && !animator.isPlaying("bump"))
{
animator.Play("idle", restart: true, loop: true);
animState = AnimState.Idle;
}
}
}
}
void handleAnim(AnimState s)
{
if (!anim.GetBool("busy"))
{
switch (s)
{
case (AnimState.LIGHT):
anim.Play("WrathPunch");
break;
case (AnimState.HEAVY):
anim.Play("WrathHeavy");
break;
}
}
}
public override void OnLoad(ConfigNode node)
{
base.OnLoad(node);
try
{
currentAnimState = (AnimState)Enum.Parse(typeof(AnimState), persistentState);
}
catch (Exception e)
{
currentAnimState = AnimState.STOPPED_START;
persistentState = currentAnimState.ToString();
print(e.Message);
}
locateAnimation();
restorePreviousAnimationState(currentAnimState);
}
protected virtual void OnAnimationFinished()
{
if (currentTransitionState != AnimState.Idle)
{
currentTransitionState = AnimState.Idle;
RefreshAnimation();
if (currentTransitionCallback != null)
{
Action oldCallback = currentTransitionCallback;
currentTransitionCallback = null;
oldCallback();
}
}
}
protected void CancelTransition()
{
if (currentTransitionState != AnimState.Idle && currentTransitionCancellable)
{
if (currentTransitionCallback != null)
{
Action oldCallback = currentTransitionCallback;
currentTransitionCallback = null;
oldCallback();
}
currentTransitionState = AnimState.Idle;
RefreshAnimation();
}
}
public void SetAnim(AnimState animState)
{
switch (state)
{
case AnimState.Idle:
anim.SetTrigger("Idle");
break;
case AnimState.Run:
anim.SetTrigger("Run");
break;
default:
break;
}
}
public override void OnLoad(ConfigNode node)
{
base.OnLoad(node);
try
{
currentAnimState = (AnimState)Enum.Parse(typeof(AnimState), persistentState);
}
catch (Exception e)
{
currentAnimState = AnimState.STOPPED_START;
persistentState = currentAnimState.ToString();
print(e.Message);
}
locateAnimation();
restorePreviousAnimationState(currentAnimState);
}
public override void Play(AnimState state, bool baseAnimate = true)
{
if (CanAnimate)
{
AnimationClip clip = GetStateClip(state);
if (clip.IsNotNull())
{
base.Play(state, false);
animator.CrossFade(clip.name, fadeLength);
}
else
{
base.Play(state, true);
}
}
}
public virtual void Setup()
{
cachedAgent = transform.GetComponentInParent <RTSAgent>();
InitialiseAudio();
animStateChanged = false;
lastAnimState = currentAnimState = AnimState.Idling;
// update to you more modern Animator component
// Animation will become depreciated soon
animator = GetComponent <Animator>();
if (animator == null)
{
animator = this.GetComponentInChildren <Animator>();
}
}
public virtual void Play(AnimState state, bool baseAnimate = true)
{
if (OnStatePlay.IsNotNull())
{
OnStatePlay(state);
}
if (CanAnimate && baseAnimate)
{
AnimationClip clip = GetStateClip(state);
if (clip.IsNotNull())
{
animator.CrossFade(clip.name, fadeLength);
}
}
}
void SetAnimState(AnimState newState)
{
if (animState == newState)
{
return;
}
Animator anim = GetComponentInChildren <Animator>();
if (null == anim)
{
Debug.LogError("Missing Animator");
}
switch (newState)
{
case AnimState.IDLE:
anim.SetTrigger("idle");
break;
case AnimState.MOVE:
anim.SetTrigger("move");
break;
case AnimState.STUNNED:
anim.SetTrigger("stunned");
break;
case AnimState.PICKUP:
anim.SetTrigger("pickup");
break;
case AnimState.THROW:
anim.SetTrigger("throw");
break;
case AnimState.WELD:
anim.SetTrigger("weld");
break;
case AnimState.SCREW:
anim.SetTrigger("screw");
break;
}
animState = newState;
}
protected void ProgressToNextState(AgentAction action)
{
if (mNextState != null)
{
if (mNextState == mCurrentState)
{
mNextState = null;
return;
}
if (null != mCurrentState)
mCurrentState.Exit();
mCurrentState = mNextState;
mCurrentState.Enter(action);
mNextState = null;
}
}
void StateSwap(AnimState newState)
{
switch (newState) {
case AnimState.Jump:
actions.Jump();
break;
case AnimState.Run:
actions.Run();
break;
case AnimState.Stay:
actions.Stay();
break;
case AnimState.Walk:
actions.Walk();
break;
default:
break;
}
}
public void setAnimState(AnimState newState, bool callback)
{
switch (newState)
{
case AnimState.PLAYING_BACKWARD:
{
setAnimSpeed(-1f);
if (currentAnimState == AnimState.STOPPED_END)//enforce play backwards from end
{
setAnimTime(1f);//no need to sample, the play update will take care of it
}
playAnimation();
break;
}
case AnimState.PLAYING_FORWARD:
{
setAnimSpeed(1f);
if (currentAnimState == AnimState.STOPPED_START)//enforce play forwards from beginning
{
setAnimTime(0f);//no need to sample, the play update will take care of it
}
playAnimation();
break;
}
case AnimState.STOPPED_END:
{
setAnimTime(1, true);
stopAnimation();
break;
}
case AnimState.STOPPED_START:
{
setAnimTime(0, true);
stopAnimation();
break;
}
}
currentAnimState = newState;
if (callback && stateChangeCallback != null)
{
stateChangeCallback.Invoke(currentAnimState);
}
}
void _PlayAnim(float hor, float ver)
{
if( hor > 0)
{
_animState = AnimState.WalkRight;
_anim.PlayAnimation("WalkRight");
return;
}
else if( hor < 0)
{
_animState = AnimState.WalkLeft;
_anim.PlayAnimation("WalkLeft");
return;
}
if(ver != 0)
{
_anim.PlayAnimation(_animState.ToString());
}
}
public void Update()
{
if (mCurrentState != null)
{
if (mCurrentState.IsFinished())
{
mCurrentState.Exit();
mCurrentState = mDefaultState;
mCurrentState.Enter(null);
}
else
{
mCurrentState.Update();
}
}
else
{
mCurrentState = mDefaultState;
mCurrentState.Enter(null);
}
}
// Update is called once per frame
void Update()
{
if(oldState != CurrentState){
switch(CurrentState){
case AnimState.attack:
animation.CrossFade("attack");
break;
case AnimState.idle:
animation.CrossFade("idle");
break;
case AnimState.run:
animation.CrossFade("running");
break;
case AnimState.skill:
animation.CrossFade("skill");
break;
}
}
if(!animation.isPlaying){
animation.CrossFade("idle");
CurrentState = AnimState.idle;
}
oldState = CurrentState;
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (stream.isWriting)
{
if (Network.peerType == NetworkPeerType.Server)
{
Vector3 pos = transform.position;
Quaternion rot = transform.rotation;
int _animState = (int)animState;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref devilHp);
stream.Serialize(ref _animState);
}
}
else
{
if (Network.peerType != NetworkPeerType.Server)
{
Vector3 revPos = Vector3.zero;
Quaternion revRot = Quaternion.identity;
// int _animState = 0;
stream.Serialize(ref revPos);
stream.Serialize(ref revRot);
stream.Serialize(ref devilHp);
stream.Serialize(ref anim);
currPos = revPos;
currRot = revRot;
animState = (AnimState)anim;
}
}
}
private void tailAnimStateChanged(AnimState state)
{
tailAnimState = state.ToString();
updateTailAnimUILabels();
updateAirstreamShield();
}
private void noseAnimStateChanged(AnimState state)
{
noseAnimState = state.ToString();
updateNoseAnimUILabels();
updateAirstreamShield();
}
private string getLabelForState(AnimState state)
{
switch (state)
{
case AnimState.STOPPED_START:
return "Open";
case AnimState.STOPPED_END:
return "Close";
case AnimState.PLAYING_FORWARD:
return "Close";
case AnimState.PLAYING_BACKWARD:
return "Open";
default:
return "Open";
}
}
private void bodyAnimStateChanged(AnimState state)
{
bodyAnimState = state.ToString();
updateBodyAnimUILabels();
updateAirstreamShield();
}
private void onAnimStateChange(AnimState newState)
{
//NOOP
}
void AnimationChange(AnimState newState)
{
if (newState == currentAnim)
return;
else
{
currentAnim = newState;
animator.ResetTrigger("Stay");
animator.ResetTrigger("Walk");
animator.SetTrigger(currentAnim.ToString());
}
if (currentAnim == AnimState.Stay)
body.constraints = RigidbodyConstraints2D.FreezePositionX | RigidbodyConstraints2D.FreezeRotation;
else
body.constraints = RigidbodyConstraints2D.FreezeRotation;
}
/// <summary>
/// Collision
/// </summary>
/// <param name="ent"></param>
public override void OnCollision(Entity ent)
{
if (ent is Dynamic)
{
if (!IsChild((Dynamic)ent))
{
// Audio object for collision of smaller circles
SoundEffect hitChild1;
SoundEffect hitChild2;
hitChild1 = _content.Load<SoundEffect>("Audio/Character/Yay_1");
hitChild2 = _content.Load<SoundEffect>("Audio/Character/Yay_2");
Random rand = new Random();
int randnum = rand.Next(2);
if (randnum == 0)
{
//Maybe check if we are losing child, if we are don't play this.
hitChild1.Play();
}
else if (randnum == 1)
{
//here too
//if (!loseChild1.IsDisposed || !loseChild2.IsDisposed)
hitChild2.Play();
}
//end of audio for collecting children
AddChild((Dynamic)ent);
((Dynamic)ent).Active = true;
_score++;
if (_animState == AnimState.IDLE)
{
_animState = AnimState.GRIN;
_curAnim = 3;
_curFrame = 0;
}
}
}
else if (ent is Enemy)
{
Enemy enm = (Enemy)ent;
if (enm.State != Button.ButtonState.CLICK)
{
switch (enm.EType)
{
case Enemy.EnemyType.SPIKEY:
{
if (_child.Count > 0)
{
Dynamic child = _child[0];
_child.RemoveAt(0);
Vector2 axis = _pos - child.Position;//child.Position - _pos;
axis.Normalize();
child.Position = _pos + axis * (Radius + child.Radius) * 1.01f;
child.AddForce(axis * 500);
child.Active = true;
//Audio for losing a child
//SoundEffect loseChild1;
//SoundEffect loseChild2;
loseChild1 = _content.Load<SoundEffect>("Audio/Character/Ohno_1");
loseChild2 = _content.Load<SoundEffect>("Audio/Character/Ohno_2");
hit1 = _content.Load<SoundEffect>("Audio/Environment/GeneralSounds/Hit");
hit2 = _content.Load<SoundEffect>("Audio/Environment/GeneralSounds/Hit2");
hit3 = _content.Load<SoundEffect>("Audio/Environment/GeneralSounds/Hit3");
Random rand = new Random();
int randnum = rand.Next(7);
switch (randnum)
{
case (0):
loseChild1.Play();
break;
case (1):
loseChild2.Play();
break;
case (2):
hit1.Play();
break;
case (3):
hit2.Play();
break;
case (4):
hit3.Play();
break;
}
//
_score--;
}
else
{
// Die
SoundEffect die;
die = _content.Load<SoundEffect>("Audio/Character/Explode");
//die.Play();
}
if (_animState == AnimState.IDLE)
{
_animState = AnimState.HIT;
_curAnim = 2;
_curFrame = 0;
}
break;
}
case Enemy.EnemyType.BURSTING:
{
break;
}
case Enemy.EnemyType.STICKY:
{
break;
}
}
}
}
else if (ent is Static)
{
ent.OnCollision(this);
}
base.OnCollision(ent);
}
/// <summary>
/// End current animation
/// </summary>
public override void AnimationEnded()
{
Random rnd = new Random();
switch (_animState)
{
case AnimState.IDLE:
{
if (rnd.Next(10) < 7)
{
_curFrame = 0;
_curAnim = 0;
_animState = AnimState.IDLE;
}
else
{
_curFrame = 0;
_curAnim = 1;
_animState = AnimState.BLINK;
}
break;
}
case AnimState.HIT:
case AnimState.BLINK:
case AnimState.GRIN:
{
_curFrame = 0;
_curAnim = 0;
_animState = AnimState.IDLE;
break;
}
}
}
void AnimationStep()
{
if (anim_state != AnimState.ANIM_END)
{
anim_state = AnimState.ANIM_ADV;
current_character.GetComponent<Animator>().speed = 1.0f;
}
}
void UpdateAnimation()
{
switch (anim_state)
{
case AnimState.ANIM_START:
anim_state = AnimState.ANIM_PAUSED;
break;
case AnimState.ANIM_PAUSED:
break;
case AnimState.ANIM_ADV:
if (current_character.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).normalizedTime > 1.0f)
anim_state = AnimState.ANIM_END;
else
{
current_time = current_character.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).normalizedTime*current_character.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).length;
if (current_time >= dest_time)
{
current_character.GetComponent<Animator>().speed = 0.0f;
anim_state = AnimState.ANIM_PAUSED;
dest_time = current_time + anim_step;
}
}
break;
case AnimState.ANIM_END:
break;
}
}
