IEnumerator ShowPose()
{
m_IsShowing = true;
CachedAnimator.SetTrigger("pose");
float delay01 = m_PoseRoleData.Effect01Data.DelayTime;
float delay02 = m_PoseRoleData.Effect02Data.DelayTime;
if (delay01 >= delay02)
{
yield return(new WaitForSeconds(delay02));
GameEntry.Entity.ShowEffect(m_PoseRoleData.Effect02Data);
yield return(new WaitForSeconds(delay01 - delay02));
GameEntry.Entity.ShowEffect(m_PoseRoleData.Effect01Data);
GameEntry.Sound.PlaySound(m_PoseRoleData.SoundId);
}
else
{
yield return(new WaitForSeconds(delay01));
GameEntry.Entity.ShowEffect(m_PoseRoleData.Effect01Data);
yield return(new WaitForSeconds(delay02 - delay01));
GameEntry.Entity.ShowEffect(m_PoseRoleData.Effect02Data);
GameEntry.Sound.PlaySound(m_PoseRoleData.SoundId);
}
}
// Use this for initialization
void Start()
{
isOn = isOnAtStart;
CachedAnimator.SetBool(isOnBoolField, isOn);
isToggledAtLeastOnce = false;
}
/// <inheritdoc/>
protected override BytesStack GetSnapshot()
{
var bytesStack = new BytesStack();
var parameters = CachedAnimator.parameters;
for (var i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
switch (parameter.type)
{
case AnimatorControllerParameterType.Float:
bytesStack.PushFloat(CachedAnimator.GetFloat(parameter.name));
bytesStack.PushString(parameter.name);
break;
case AnimatorControllerParameterType.Int:
bytesStack.PushInt(CachedAnimator.GetInteger(parameter.name));
bytesStack.PushString(parameter.name);
break;
case AnimatorControllerParameterType.Bool:
bytesStack.PushBool(CachedAnimator.GetBool(parameter.name));
bytesStack.PushString(parameter.name);
break;
}
}
return(bytesStack);
}
protected override void OnInitializeTrashObject()
{
humanState = new StateMachine <HumanState> (BeginHumanState, EndHumanState);
if (anim_HashToState == null)
{
InitializeNameHashes();
}
anim_TrashBehaviors = CachedAnimator.GetBehaviours <TrashBehavior> ();
if (anim_TrashBehaviors != null)
{
for (int i = 0; i < anim_TrashBehaviors.Length; i++)
{
anim_TrashBehaviors[i].SubscribeToStateEvents(OnTrashAnimStateBegins, OnTrashAnimStateEnds);
}
}
else
{
Debug.LogError("No trash behavior on : " + name);
}
OnInitialize();
}
/// <inheritdoc/>
protected override void ApplySnapshot(Message message)
{
var parameters = CachedAnimator.parameters;
while (message.Content.Count > 0)
{
var parameterName = message.Content.PopString();
var parameterHash = Animator.StringToHash(parameterName);
var parameter = parameters.First(param => param.nameHash == parameterHash);
if (parameter == null)
{
continue;
}
switch (parameter.type)
{
case AnimatorControllerParameterType.Float:
CachedAnimator.SetFloat(parameterHash, message.Content.PopFloat());
break;
case AnimatorControllerParameterType.Int:
CachedAnimator.SetInteger(parameterHash, message.Content.PopInt());
break;
case AnimatorControllerParameterType.Bool:
CachedAnimator.SetBool(parameterHash, message.Content.PopBool());
break;
}
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (!collision.gameObject.CompareTag("Arrow"))
{
return;
}
CachedAnimator.Play(CachedStats.CurrentHp > 0 ? "SkeletonHurt" : "SkeletonDie");
}
private IEnumerator AttackAnimation()
{
CachedAnimator.Play("EnemyWizardAttack");
yield return(new WaitForSeconds(.5f));
CachedAnimator.Play("EnemyWizardIddle");
yield return(null);
}
private void SetupAnimatorStateMachineBehaviours()
{
PlaySoundStateMachineBehaviour[] soundPlayers = CachedAnimator.GetBehaviours <PlaySoundStateMachineBehaviour>();
for (int i = 0; i < soundPlayers.Length; i++)
{
soundPlayers[i].Setup(CachedAudioSource);
}
}
private void Update()
{
if (transform.position.x > -9.5f)
{
CachedAnimator.Play("SkeletonWalk");
}
else if (transform.position.x == -9.5f && Time.time > _nextAttack)
{
_nextAttack = Time.time + _attackRate;
StartCoroutine(PlayAnimation("SkeletonAttack"));
}
}
void Update()
{
if (transform.position.x > 3)
{
CachedAnimator.Play("EnemyWizardRun");
}
if (Time.time > _nextAttack && transform.position.x == 3)
{
_nextAttack = Time.time + _attackRate;
StartCoroutine(AttackAnimation());
}
}
protected void ClearAnimationStates()
{
for (int i = 0; i < list_States.Count; i++)
{
if (!HasAnimationParameter(list_States[i].ToString()))
{
continue;
}
CachedAnimator.SetBool(list_States[i].ToString(), false);
}
}
/// <summary>
/// Sets the parameter's float value and sends it to corresponding mocks
/// </summary>
/// <param name="parameterName">The parameter name</param>
/// <param name="value">The new parameter value</param>
public void SetFloat(string parameterName, float value)
{
CachedAnimator.SetFloat(parameterName, value);
if (!IsInitialized)
{
return;
}
var bytesStack = new BytesStack();
bytesStack.PushFloat(value);
bytesStack.PushString(parameterName);
bytesStack.PushEnum <AnimatorCommandType>((int)AnimatorCommandType.SetFloatByName);
SendDelta(bytesStack, MessageType.ReliableSequenced);
}
protected void SetAnimationState(string state, bool enabled, bool clearStates)
{
if (!HasAnimationParameter(state))
{
return;
}
if (clearStates)
{
ClearAnimationStates();
}
CachedAnimator.SetBool(state, enabled);
}
public bool Open()
{
CurrentStateInfo = CachedAnimator.GetCurrentAnimatorStateInfo(0);
if (CurrentStateInfo.IsName("idle") == true)
{
CachedAnimator.Play("openDoors", 0);
return(true);
}
else if (CurrentStateInfo.IsName("closeDoors") == true)
{
InterruptClosing(CurrentStateInfo);
}
return(false);
}
private IEnumerator PlayAnimation()
{
if (FindClosestEnemy() < 15)
{
CachedAnimator.Play("WizardAttack");
yield return(new WaitForSeconds(.5f));
CachedAnimator.Play("WizardIddle");
}
else
{
CachedAnimator.Play("WizardIddle");
}
yield return(null);
}
// Use this for initialization
void Start()
{
// Setup flags
isOpen = openByDefault;
CachedAnimator.SetBool(OpenField, isOpen);
// Setup switches
allUniqueSwitches.Clear();
foreach (Switch button in allSwitches)
{
if ((button != null) && (allUniqueSwitches.Contains(button) == false))
{
button.OnAfterStateChanged += Button_OnAfterStateChanged;
allUniqueSwitches.Add(button);
}
}
}
void SwingTyreIron()
{
swing_Direction = (current_PowerUpTarget - (Vector2)bind_TyreIronLookAt.position);
float heightDiff = current_PowerUpTarget.y - bind_TyreIronLookAt.position.y;
CachedAnimator.SetFloat(PARAM_TYRE_IRON_ANGLE, heightDiff);
playerState.SetState(TrashPlayerState.Hitting);
swing_Direction = ((Vector2)current_PowerUpTarget - (Vector2)bind_TyreIronLookAt.position).normalized;
swing_Power = max_SwingPower * current_Power_N;
swing_Force = swing_Direction * swing_Power;
StartCoroutine(HandleSwingTyreIron(heightDiff));
}
/// <inheritdoc/>
protected override void ApplyDelta(Message message)
{
var commandType = message.Content.PopEnum <AnimatorCommandType>();
switch (commandType)
{
case AnimatorCommandType.SetFloatById:
CachedAnimator.SetFloat(message.Content.PopInt(), message.Content.PopFloat());
break;
case AnimatorCommandType.SetFloatByName:
CachedAnimator.SetFloat(message.Content.PopString(), message.Content.PopFloat());
break;
default:
throw new ArgumentOutOfRangeException();
}
}
protected internal override void OnUpdate(float elapseSeconds, float realElapseSeconds)
{
base.OnUpdate(elapseSeconds, realElapseSeconds);
if (Input.GetKeyDown(KeyCode.A))
{
CachedAnimator.SetBool(IsWalking, true);
}
if (Input.GetKeyDown(KeyCode.B))
{
CachedAnimator.SetBool(IsRunning, true);
}
if (Input.GetKeyDown(KeyCode.C))
{
CachedAnimator.SetBool(IsAttacking, true);
}
}
private IEnumerator PlayAnimation(string animationName)
{
CachedAnimator.Play(animationName);
yield return(new WaitForSeconds(_attackRate));
}
private void CacheEventRouters()
{
CachedEventRouters = CachedAnimator.GetBehaviours <StateMachineEventsRouter>();
}
private void InterruptClosing(AnimatorStateInfo info)
{
OpeningAnimationPositionToSet = 1.0f - (info.normalizedTime % 1.0f);
CachedAnimator.Play("openDoors", 0, OpeningAnimationPositionToSet);
}
void UpdateActivation(bool rightSideUp)
{
CachedAnimator.SetBool(RightSideUpBoolField, rightSideUp);
}
protected override void OnUpdate(float elapseSeconds, float realElapseSeconds)
{
base.OnUpdate(elapseSeconds, realElapseSeconds);
m_ElapseSeconds += elapseSeconds;
if (m_ElapseSeconds >= 1f)
{
m_ElapseSeconds -= 1f;
if (m_CoolDown > 0)
{
m_CoolDown--;
if (m_CoolDown == 0)
{
m_Bullet = m_Charactor_BasekData.BulletMax;
}
}
}
if (m_ReverseMoveDirectionDuraction > 0f)
{
m_ReverseMoveDirectionDuraction -= elapseSeconds;
if (m_ReverseMoveDirectionDuraction <= 0f)
{
if (m_IsReverseMoveDirection)
{
m_IsReverseMoveDirection = false;
}
m_ReverseMoveDirectionDuraction = 0f;
}
}
float hor = Input.GetAxis("Horizontal");
float ver = Input.GetAxis("Vertical");
bool isRunning = !Mathf.Approximately(hor, 0f) || !Mathf.Approximately(ver, 0f);
if (isRunning)
{
if (m_IsReverseMoveDirection)
{
hor *= -1f;
ver *= -1f;
}
Vector3 dir = new Vector3(hor, 0, ver).normalized;
CachedTransform.forward = dir;
CachedTransform.position += dir * m_MoveSpeed * elapseSeconds;
CheckMoveCollision();
}
if (m_IsRunning != isRunning)
{
m_IsRunning = isRunning;
if (CachedAnimator != null)
{
CachedAnimator.SetBool("isRunning", m_IsRunning);
}
}
if (m_Weapon == null)
{
//Debug.LogWarning("m_Weapon == null.");
return;
}
if (m_CoolDown > 0)
{
return;
}
if (Input.GetKey(KeyCode.K) && m_Weapon.CanFire())
{
m_Weapon.StartFire();
m_Bullet--;
if (m_Bullet <= 0)
{
m_CoolDown = m_Charactor_BasekData.CoolDown;
}
}
}
protected void SetAnimationTrigger(string trigger)
{
CachedAnimator.SetTrigger(trigger);
}
