protected virtual void UpdateAnimators()
{
if (_animator != null)
{
MMAnimator.UpdateAnimatorFloat(_animator, "Speed", _currentSpeed, _animatorParameters);
}
}
public virtual void Tackle()
{
SfxManager.Instance.TackleStart();
TackleParticles.Play();
LastTackleTimestamp = Time.time;
MMAnimator.UpdateAnimatorTrigger(_animator, "Dash", _animatorParameters);
}
/// <summary>
/// Override this to send parameters to the character's animator. This is called once per cycle, by the Character
/// class, after Early, normal and Late process().
/// </summary>
public override void UpdateAnimator()
{
if (CurrentWeapon == null)
{
return;
}
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.IdleAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponIdle), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.StartAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponStart), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.DelayBeforeUseAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBeforeUse), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.UseAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBeforeUse || CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponUse || CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBetweenUses), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.SingleUseAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponUse), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.DelayBetweenUsesAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBetweenUses), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.StopAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponStop), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.ReloadStartAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponReloadStart), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.ReloadAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponReload), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.ReloadStopAnimationParameter, (CurrentWeapon.WeaponState.CurrentState == Weapon.WeaponStates.WeaponReloadStop), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.EquippedAnimationParameter, true, _character._animatorParameters);
if (_aimableWeapon != null)
{
MMAnimator.UpdateAnimatorFloat(_animator, CurrentWeapon.WeaponAngleAnimationParameter, _aimableWeapon.CurrentAngle, _character._animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, CurrentWeapon.WeaponAngleRelativeAnimationParameter, _aimableWeapon.CurrentAngleRelative, _character._animatorParameters);
}
else
{
MMAnimator.UpdateAnimatorFloat(_animator, CurrentWeapon.WeaponAngleAnimationParameter, 0f, _character._animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, CurrentWeapon.WeaponAngleRelativeAnimationParameter, 0f, _character._animatorParameters);
}
}
/// <summary>
/// Updates the block's animator.
/// </summary>
protected virtual void UpdateAnimator()
{
if (_animator != null)
{
MMAnimator.UpdateAnimatorBool(_animator, "Shaking", _shaking);
}
}
/// <summary>
/// Triggered when the shark collides with the player
/// </summary>
/// <param name="collidingObject">the object that collides with our shark.</param>
protected virtual void OnTriggerEnter2D(Collider2D collidingObject)
{
// we verify that the colliding object is a PlayableCharacter with the Player tag. If not, we do nothing.
PlayableCharacter player = collidingObject.GetComponent <PlayableCharacter>();
if (player == null)
{
return;
}
if (collidingObject.tag != "Player")
{
return;
}
// we shake the camera - uncomment these two lines if you want to add a shake effect when the shark collides with your player. I thought it was a bit too much.
//Vector3 ShakeParameters = new Vector3(1.5f, 0.5f, 1f);
//_camera.Shake(ShakeParameters);
// we instantiate an explosion at the point of impact.
GameObject explosion = (GameObject)Instantiate(Explosion);
explosion.transform.position = new Vector3(transform.GetComponent <Renderer>().bounds.min.x, transform.GetComponent <Renderer>().bounds.center.y, 0);
MMAnimator.UpdateAnimatorBoolIfExists(explosion.GetComponent <Animator>(), "Explode", true);
// we turn the object inactive so it can be instantiated again
gameObject.SetActive(false);
}
/// <summary>
/// This coroutine handles the climb sequence
/// </summary>
/// <returns></returns>
protected virtual IEnumerator Climb()
{
// we start to climb
_movement.ChangeState(CharacterStates.MovementStates.LedgeClimbing);
MMAnimator.UpdateAnimatorBool(_animator, "LedgeClimbing", true, _character._animatorParameters);
// we prevent all other input
_inputManager.InputDetectionActive = false;
// we wait until the climb animation is complete
yield return(_climbingAnimationDelay);
// we restore input and go to idle
_inputManager.InputDetectionActive = true;
MMAnimator.UpdateAnimatorBool(_animator, "LedgeClimbing", false, _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "Idle", true, _character._animatorParameters);
_animator.Play(IdleAnimationName);
// we teleport our character to its new position (this offset is specified on the Ledge object)
this.transform.position = _ledge.transform.position + _ledge.ClimbOffset;
// we go back to idle and detach from the ledge
_movement.ChangeState(CharacterStates.MovementStates.Idle);
_controller.GravityActive(true);
DetachFromLedge();
}
/// <summary>
/// Updates the animator's parameters
/// </summary>
protected virtual void UpdateAnimator()
{
if (_animator != null)
{
MMAnimator.UpdateAnimatorFloat(_animator, "Speed", _rigidBody2D.velocity.magnitude);
MMAnimator.UpdateAnimatorInteger(_animator, "Armor", _currentArmor);
}
}
public override void UpdateAnimator()
{
if (GetComponent <InputManager>() != null)
{
MMAnimator.UpdateAnimatorFloat(_animator, "Speed", Mathf.Abs(_normalizedHorizontalSpeed), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "Walking", (_movement.CurrentState == CharacterStates.MovementStates.Walking),
_character._animatorParameters);
}
}
/// <summary>
/// Override this to send parameters to the character's animator. This is called once per cycle, by the Character
/// class, after Early, normal and Late process().
/// </summary>
public virtual void UpdateAnimator()
{
for (int i = 0; i < Animators.Count; i++)
{
MMAnimator.UpdateAnimatorBool(Animators[i], IdleAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponIdle), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], StartAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponStart), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], DelayBeforeUseAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBeforeUse), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], UseAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBeforeUse || WeaponState.CurrentState == Weapon.WeaponStates.WeaponUse || WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBetweenUses), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], SingleUseAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponUse), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], DelayBetweenUsesAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBetweenUses), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], StopAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponStop), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], ReloadStartAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponReloadStart), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], ReloadAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponReload), _animatorParameters[i]);
MMAnimator.UpdateAnimatorBool(Animators[i], ReloadStopAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponReloadStop), _animatorParameters[i]);
if (_aimableWeapon != null)
{
MMAnimator.UpdateAnimatorFloat(Animators[i], WeaponAngleAnimationParameter, _aimableWeapon.CurrentAngle, _animatorParameters[i]);
MMAnimator.UpdateAnimatorFloat(Animators[i], WeaponAngleRelativeAnimationParameter, _aimableWeapon.CurrentAngleRelative, _animatorParameters[i]);
}
else
{
MMAnimator.UpdateAnimatorFloat(Animators[i], WeaponAngleAnimationParameter, 0f, _animatorParameters[i]);
MMAnimator.UpdateAnimatorFloat(Animators[i], WeaponAngleRelativeAnimationParameter, 0f, _animatorParameters[i]);
}
}
if (_ownerAnimator != null)
{
MMAnimator.UpdateAnimatorBool(_ownerAnimator, IdleAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponIdle), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, StartAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponStart), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, DelayBeforeUseAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBeforeUse), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, UseAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBeforeUse || WeaponState.CurrentState == Weapon.WeaponStates.WeaponUse || WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBetweenUses), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, SingleUseAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponUse), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, DelayBetweenUsesAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponDelayBetweenUses), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, StopAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponStop), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, ReloadStartAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponReloadStart), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, ReloadAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponReload), _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorBool(_ownerAnimator, ReloadStopAnimationParameter, (WeaponState.CurrentState == Weapon.WeaponStates.WeaponReloadStop), _ownerAnimatorParameters);
if (_aimableWeapon != null)
{
MMAnimator.UpdateAnimatorFloat(_ownerAnimator, WeaponAngleAnimationParameter, _aimableWeapon.CurrentAngle, _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorFloat(_ownerAnimator, WeaponAngleRelativeAnimationParameter, _aimableWeapon.CurrentAngleRelative, _ownerAnimatorParameters);
}
else
{
MMAnimator.UpdateAnimatorFloat(_ownerAnimator, WeaponAngleAnimationParameter, 0f, _ownerAnimatorParameters);
MMAnimator.UpdateAnimatorFloat(_ownerAnimator, WeaponAngleRelativeAnimationParameter, 0f, _ownerAnimatorParameters);
}
}
}
/// <summary>
/// This is called at Update() and sets each of the animators parameters to their corresponding State values
/// </summary>
protected virtual void UpdateAnimators()
{
if (_animator != null)
{
MMAnimator.UpdateAnimatorBool(_animator, "Grounded", true, _animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "ForwardSpeed", _currentSpeed, _animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "RotationSpeed", _currentRotationSpeed, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "Goal", Goal, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "GoalInProgress", GoalInProgress, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "RobotDance", RobotDance, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "Dead", Dead, _animatorParameters);
}
}
/// <summary>
/// Changes the character's current weapon to the one passed as a parameter
/// </summary>
/// <param name="newWeapon">The new weapon.</param>
public virtual void ChangeWeapon(Weapon newWeapon, string weaponID, bool combo = false)
{
// if the character already has a weapon, we make it stop shooting
if (CurrentWeapon != null)
{
if (!combo)
{
ShootStop();
MMAnimator.UpdateAnimatorBool(_animator, CurrentWeapon.EquippedAnimationParameter, false, _character._animatorParameters);
Destroy(CurrentWeapon.gameObject);
}
}
if (newWeapon != null)
{
if (!combo)
{
CurrentWeapon = (Weapon)Instantiate(newWeapon, WeaponAttachment.transform.position + newWeapon.WeaponAttachmentOffset, WeaponAttachment.transform.rotation);
}
CurrentWeapon.transform.parent = WeaponAttachment.transform;
CurrentWeapon.SetOwner(_character, this);
CurrentWeapon.WeaponID = weaponID;
_aimableWeapon = CurrentWeapon.GetComponent <WeaponAim> ();
// we handle (optional) inverse kinematics (IK)
if (_weaponIK != null)
{
_weaponIK.SetHandles(CurrentWeapon.LeftHandHandle, CurrentWeapon.RightHandHandle);
}
// we turn off the gun's emitters.
CurrentWeapon.Initialization();
CurrentWeapon.InitializeComboWeapons();
CurrentWeapon.InitializeAnimatorParameters();
InitializeAnimatorParameters();
if ((_character != null) && !combo)
{
if (!_character.IsFacingRight)
{
if (CurrentWeapon != null)
{
CurrentWeapon.FlipWeapon();
CurrentWeapon.FlipWeaponModel();
}
}
}
}
else
{
CurrentWeapon = null;
}
}
/// <summary>
/// Initialization
/// </summary>
protected virtual void Initialization()
{
// we get the animator
_animator = GetComponent <Animator>();
_numberOfHitsLeft = NumberOfAllowedHits;
if (_numberOfHitsLeft > 0)
{
MMAnimator.UpdateAnimatorBool(_animator, "Off", false);
}
else
{
MMAnimator.UpdateAnimatorBool(_animator, "Off", true);
}
}
protected virtual void InitializeAnimatorParameters()
{
if (_animator == null)
{
return;
}
if (!_animator.isActiveAndEnabled)
{
return;
}
_animatorParameters = new List <string>();
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Dash", AnimatorControllerParameterType.Trigger, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Shoot", AnimatorControllerParameterType.Trigger, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Speed", AnimatorControllerParameterType.Float, _animatorParameters);
}
/// <summary>
/// Initializes the animator parameters.
/// </summary>
protected virtual void InitializeAnimatorParameters()
{
if (_animator == null)
{
return;
}
_animatorParameters = new List <string>();
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Grounded", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "xSpeed", AnimatorControllerParameterType.Float, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "ySpeed", AnimatorControllerParameterType.Float, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "CollidingLeft", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "CollidingRight", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "CollidingBelow", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "CollidingAbove", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Idle", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Alive", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "FacingRight", AnimatorControllerParameterType.Bool, _animatorParameters);
}
/// <summary>
/// Animates the character if it has an animator set
/// Also flips the character if needed
/// </summary>
public virtual void AnimateCharacter()
{
if (_destination == null)
{
return;
}
if (_destination.transform.position.x - _offset.x < transform.position.x)
{
if (CharacterIsFacingRight)
{
Flip();
}
}
if (_destination.transform.position.x - _offset.x > transform.position.x)
{
if (!CharacterIsFacingRight)
{
Flip();
}
}
// if we have an animator we'll want to let it know if our character is moving or not
if (_animator != null)
{
// if we've moved since last frame, we haven't reached our destination yet, so we set our current speed at 1
if (_positionLastFrame != transform.position)
{
_currentSpeed = 1f;
}
else
{
// if we haven't moved last frame, we're static
_currentSpeed = 0f;
}
// we pass that parameter to our animator
MMAnimator.UpdateAnimatorFloat(_animator, "Speed", _currentSpeed);
}
_positionLastFrame = transform.position;
}
/// <summary>
/// Initializes the animator parameters.
/// </summary>
protected virtual void InitializeAnimatorParameters()
{
if (_animator == null)
{
return;
}
if (!_animator.isActiveAndEnabled)
{
return;
}
_animatorParameters = new List <string>();
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Grounded", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "ForwardSpeed", AnimatorControllerParameterType.Float, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "RotationSpeed", AnimatorControllerParameterType.Float, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Goal", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "GoalInProgress", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "RobotDance", AnimatorControllerParameterType.Bool, _animatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_animator, "Dead", AnimatorControllerParameterType.Bool, _animatorParameters);
}
/// <summary>
/// Adds required animator parameters to the animator parameters list if they exist
/// </summary>
public virtual void InitializeAnimatorParameters()
{
for (int i = 0; i < Animators.Count; i++)
{
_animatorParameters.Add(new List <string>());
}
for (int i = 0; i < Animators.Count; i++)
{
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], WeaponAngleAnimationParameter, AnimatorControllerParameterType.Float, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], WeaponAngleRelativeAnimationParameter, AnimatorControllerParameterType.Float, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], IdleAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], StartAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], DelayBeforeUseAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], DelayBetweenUsesAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], StopAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], ReloadStartAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], ReloadStopAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], ReloadAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], SingleUseAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
MMAnimator.AddAnimatorParamaterIfExists(Animators[i], UseAnimationParameter, AnimatorControllerParameterType.Bool, _animatorParameters[i]);
}
if (_ownerAnimator != null)
{
_ownerAnimatorParameters = new List <string>();
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, WeaponAngleAnimationParameter, AnimatorControllerParameterType.Float, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, WeaponAngleRelativeAnimationParameter, AnimatorControllerParameterType.Float, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, IdleAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, StartAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, DelayBeforeUseAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, DelayBetweenUsesAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, StopAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, ReloadStartAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, ReloadStopAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, ReloadAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, SingleUseAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
MMAnimator.AddAnimatorParamaterIfExists(_ownerAnimator, UseAnimationParameter, AnimatorControllerParameterType.Bool, _ownerAnimatorParameters);
}
}
/// <summary>
/// Triggered when a CorgiController touches the platform
/// </summary>
/// <param name="controller">The corgi controller that collides with the platform.</param>
public virtual void OnTriggerEnter2D(Collider2D collider)
{
CorgiController controller = collider.GetComponent <CorgiController>();
if (controller == null)
{
return;
}
// if the block has spent all its hits, we do nothing
if (_numberOfHitsLeft == 0)
{
return;
}
if (collider.transform.position.y < transform.position.y)
{
// if the collider's y position is less than the block's y position, we're hitting it from below, we trigger the event
_hit = true;
_numberOfHitsLeft--;
GameObject spawned = (GameObject)Instantiate(SpawnedObject);
spawned.transform.position = transform.position;
spawned.transform.rotation = Quaternion.identity;
if (AnimateSpawn)
{
StartCoroutine(MMMovement.MoveFromTo(spawned, transform.position, new Vector2(transform.position.x + SpawnDestination.x, transform.position.y + GetComponent <BoxCollider2D>().size.y + SpawnDestination.y), SpawnSpeed, 0.05f));
}
else
{
spawned.transform.position = transform.position + SpawnDestination;
}
}
if (_numberOfHitsLeft == 0)
{
MMAnimator.UpdateAnimatorBool(_animator, "Off", true);
}
}
/// <summary>
/// This is called at Update() and sets each of the animators parameters to their corresponding State values
/// </summary>
protected virtual void UpdateAnimators()
{
if ((UseDefaultMecanim) && (_animator != null))
{
MMAnimator.UpdateAnimatorBool(_animator, "Grounded", _controller.State.IsGrounded, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "Alive", (ConditionState.CurrentState != CharacterStates.CharacterConditions.Dead), _animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "xSpeed", _controller.Speed.x, _animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "ySpeed", _controller.Speed.y, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "CollidingLeft", _controller.State.IsCollidingLeft, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "CollidingRight", _controller.State.IsCollidingRight, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "CollidingBelow", _controller.State.IsCollidingBelow, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "CollidingAbove", _controller.State.IsCollidingAbove, _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "Idle", (MovementState.CurrentState == CharacterStates.MovementStates.Idle), _animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "FacingRight", IsFacingRight, _animatorParameters);
foreach (CharacterAbility ability in _characterAbilities)
{
if (ability.enabled && ability.AbilityInitialized)
{
ability.UpdateAnimator();
}
}
}
}
/// <summary>
/// Updates the animator.
/// </summary>
protected virtual void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "Hit", _hit);
}
/// <summary>
/// Updates all mecanim animators.
/// </summary>
protected override void UpdateAllMecanimAnimators()
{
MMAnimator.UpdateAnimatorBoolIfExists(_animator, "Grounded", _grounded);
MMAnimator.UpdateAnimatorBoolIfExists(_animator, "Jumping", _jumping);
MMAnimator.UpdateAnimatorFloatIfExists(_animator, "VerticalSpeed", _rigidbodyInterface.Velocity.y);
}
/// <summary>
/// At the end of each cycle, we send our character's animator the current flying status
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "Flying", (_movement.CurrentState == CharacterStates.MovementStates.Flying), _character._animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "FlySpeed", Mathf.Abs(_controller.Speed.magnitude), _character._animatorParameters);
}
/// <summary>
/// At the end of each cycle, we send our current LookingUp status to the animator
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "LedgeHanging", (_movement.CurrentState == CharacterStates.MovementStates.LedgeHanging), _character._animatorParameters);
}
/// <summary>
/// At the end of the ability's cycle, we send our current crouching and crawling states to the animator
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "Crouching", (_movement.CurrentState == CharacterStates.MovementStates.Crouching), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "Crawling", (_movement.CurrentState == CharacterStates.MovementStates.Crawling), _character._animatorParameters);
}
/// <summary>
/// At the end of the ability's cycle, we send our current crouching and crawling states to the animator
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "Activating", _activating, _character._animatorParameters);
}
/// <summary>
/// At the end of each cycle, we send our character's animator the current following status
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "FollowingPath", (_movement.CurrentState == CharacterStates.MovementStates.FollowingPath), _character._animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "FollowingPathSpeed", Mathf.Abs(_mmPathMovement.CurrentSpeed.magnitude), _character._animatorParameters);
}
/// <summary>
/// At the end of each cycle, we send our Running status to the character's animator
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "Swimming", (_swimDurationLeft > 0f), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "SwimmingIdle", (_movement.CurrentState == CharacterStates.MovementStates.SwimmingIdle), _character._animatorParameters);
}
public virtual void Shoot()
{
MMAnimator.UpdateAnimatorTrigger(_animator, "Shoot", _animatorParameters);
StartCoroutine(ShootCoroutine());
}
/// <summary>
/// At the end of each cycle, we update our animator with our various states
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "LadderClimbing", (_movement.CurrentState == CharacterStates.MovementStates.LadderClimbing), _character._animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "LadderClimbingSpeedX", CurrentLadderClimbingSpeed.x, _character._animatorParameters);
MMAnimator.UpdateAnimatorFloat(_animator, "LadderClimbingSpeedY", CurrentLadderClimbingSpeed.y, _character._animatorParameters);
}
/// <summary>
/// At the end of each cycle, sends Jumping states to the Character's animator
/// </summary>
public override void UpdateAnimator()
{
MMAnimator.UpdateAnimatorBool(_animator, "Jumping", (_movement.CurrentState == CharacterStates.MovementStates.Jumping), _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "DoubleJumping", _doubleJumping, _character._animatorParameters);
MMAnimator.UpdateAnimatorBool(_animator, "HitTheGround", _controller.State.JustGotGrounded, _character._animatorParameters);
}
