// OnStateEnter is called before OnStateEnter is called on any state inside this state machine
 //override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
 //
 //}
 // OnStateUpdate is called before OnStateUpdate is called on any state inside this state machine
 //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
 //
 //}
 // OnStateExit is called before OnStateExit is called on any state inside this state machine
 public override void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     animator.ResetTrigger("prep");
     animator.ResetTrigger("draw");
     animator.ResetTrigger("vote");
     animator.ResetTrigger("result");
 }
 public override void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     animator.ResetTrigger ("Attack1");
     animator.ResetTrigger ("Attack2");
     animator.ResetTrigger ("Attack3");
     animator.ResetTrigger ("ChargedAttack");
     animator.SetBool ("HeavyCombo", false);
 }
 // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
 //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
 //
 //}
 // OnStateExit is called when a transition ends and the state machine finishes evaluating this state
 public override void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     animator.GetComponent<Character>().Attack = false;
     if (stateInfo.IsTag("attack")) {
         animator.GetComponent<Character>().MeleeAttack();
     }
     animator.ResetTrigger("attack");
     animator.ResetTrigger("throw");
 }
 // OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
 //override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
 //
 //}
 // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
 public override void OnStateUpdate(Animator animator, AnimatorStateInfo stateinfo, int layerindex)
 {
     if (Player.Instance.OnGround) {
         animator.SetBool("land", false);
         animator.ResetTrigger("jump");
     }
 }
        private IEnumerator PlayReloadEffect(float duration)
        {
            animator?.ResetTrigger("Attack");
            animator?.SetTrigger("Reload");

            yield return(new WaitForSeconds(duration));

            currentMagazine = weaponProperties[(int)WeaponProperty.MagazineSize];
            isReloading     = false;
        }
Beispiel #6
0
	//public static bool fade = false;
	void Start () {
		
		anim = GetComponent<Animator>();
		spr = GetComponent<SpriteRenderer>();
		anim.ResetTrigger("boltFade");
		bolt = false;
		//		spr.color = Color.red;
		//		Debug.Log(spr.color);
		//gameObject.GetComponent<Rigidbody2D>().simulated = false;
		
		
	}
    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    public override void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        var minion = animator.gameObject.GetComponent<Minion>();
        minion.navMeshAgent.SetDestination(minion.gatheringFlag.transform.position);
        minion.navMeshAgent.Resume();

        Minion.TargetType targetType = minion.UpdateTarget();
        if (targetType == Minion.TargetType.Minion)
        {
            animator.SetTrigger("TargetMinion");
            animator.ResetTrigger("TargetConstruction");
            animator.ResetTrigger("NoTarget");
        }
        else if (targetType == Minion.TargetType.Construction)
        {
            animator.SetTrigger("TargetConstruction");
            animator.ResetTrigger("TargetMinion");
            animator.ResetTrigger("NoTarget");
        }
        else
        {
            animator.SetTrigger("NoTarget");
            animator.ResetTrigger("TargetConstruction");
            animator.ResetTrigger("TargetMinion");
        }

        animator.SetBool("Arrived", minion.HasArrived());
    }
Beispiel #8
0
    public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        animator?.ResetTrigger("ReachedTarget");
        m_owner = animator.GetComponent <Ship>();

        if (m_owner == null)
        {
            Debug.LogError("Ship component not found");
        }

        m_ownerNavMeshAgent = m_owner.GetComponent <NavMeshAgent>();

        if (m_ownerNavMeshAgent == null)
        {
            Debug.LogError("Ship doesn't have nav mesh agent");
        }
        m_ownerNavMeshAgent.SetDestination(m_owner.m_targetDestination.position);
        m_distanceThreshold = m_owner.m_distanceToPointThreshold;
    }
    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    public override void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        var minion = animator.gameObject.GetComponent<Minion>();

        minion.ChaseEnemy();
        attackTimer += Time.deltaTime;
        if(attackTimer >= attackInterval)
        {
            attackTimer -= attackInterval;
            minion.AttackEnemy();
        }

        Vector3 currFlagPos = flag.transform.position;

        if ((enterFlagPos - currFlagPos).sqrMagnitude >
        flag.smallMoveRange *
        flag.smallMoveRange)
            animator.SetBool("FlagMove", true);
        else animator.SetBool("FlagMove", false);

        //animator.SetBool("FlagMove", (enterFlagPos - currFlagPos).sqrMagnitude >
        //flag.smallMoveRange *
        //flag.smallMoveRange);

        Minion.TargetType targetType = minion.UpdateTarget();
        if (targetType == Minion.TargetType.Minion)
        {
            animator.SetTrigger("TargetMinion");
            animator.ResetTrigger("TargetConstruction");
            animator.ResetTrigger("NoTarget");
        }
        else if (targetType == Minion.TargetType.Construction)
        {
            animator.SetTrigger("TargetConstruction");
            animator.ResetTrigger("TargetMinion");
            animator.ResetTrigger("NoTarget");
        }
        else
        {
            animator.SetTrigger("NoTarget");
            animator.ResetTrigger("TargetConstruction");
            animator.ResetTrigger("TargetMinion");
        }
    }
Beispiel #10
0
 override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 => animator?.ResetTrigger(parameter);
    // Update is called once per frame
    public virtual void Update()
    {
        if (isDead)
        {
            if (DeadRoutine == null)
            {
                DeadRoutine = OnDead();
            }
            return;
        }

        isLight = WorldBehaviour.instance.isLight;

        if (actionStamp >= 0 && actionStamp < actionDelay)
        {
            actionStamp += Time.deltaTime;
        }
        else
        {
            actionDelay = 0f;
            actionStamp = -1f;
        }

        if (actionStamp >= 0)
        {
            hspeed = 0f;
            vspeed = 0f;
            return;
        }

        if (Constants.NearZero(hspeed))
        {
            hspeed = 0f;
        }

        if (landingStamp >= 0 && landingStamp < landingDelay)
        {
            landingStamp += Time.deltaTime;
            hspeed        = hspeed * 0.8f;
        }
        else
        {
            landingStamp = -1f;
        }

        #region MovementBehaviour

        /// vertical movement check
        ///
        transform.position += Vector3.up * vspeed;

        if (isGravity)
        {
            vspeed += Constants.gravity;
        }

        col.enabled = false;

        RaycastHit2D vhit =
            isLight ? Physics2D.Raycast(transform.position, Vector2.up, vspeed <= 0 ? vspeed : col.size.y + vspeed, (1 << LayerMask.NameToLayer("LightBlock")) | (1 << LayerMask.NameToLayer("GreyBlock")))
            : Physics2D.Raycast(transform.position, Vector2.up, vspeed <= 0 ? vspeed : col.size.y + vspeed, 1 << LayerMask.NameToLayer("ShadowBlock") | (1 << LayerMask.NameToLayer("GreyBlock")));

        RaycastHit2D ghit =
            isLight ? Physics2D.Raycast(transform.position, Vector2.up, vspeed <= 0 ? vspeed : 0, (1 << LayerMask.NameToLayer("LightBlock")) | (1 << LayerMask.NameToLayer("LightLadder")) | (1 << LayerMask.NameToLayer("GreyBlock")) | (1 << LayerMask.NameToLayer("GreyLadder")))
            : Physics2D.Raycast(transform.position, Vector2.up, vspeed <= 0 ? vspeed : 0, 1 << LayerMask.NameToLayer("ShadowBlock") | 1 << LayerMask.NameToLayer("ShadowLadder") | (1 << LayerMask.NameToLayer("GreyBlock")) | (1 << LayerMask.NameToLayer("GreyLadder")));

        RaycastHit2D uhit =
            isLight ? Physics2D.Raycast(transform.position + Vector3.up, Vector2.up, vspeed <= 0 ? 1 : 0, (1 << LayerMask.NameToLayer("LightBlock")) | (1 << LayerMask.NameToLayer("LightLadder")) | (1 << LayerMask.NameToLayer("GreyBlock")) | (1 << LayerMask.NameToLayer("GreyLadder")))
            : Physics2D.Raycast(transform.position + Vector3.up, Vector2.up, vspeed <= 0 ? 1 : 0, 1 << LayerMask.NameToLayer("ShadowBlock") | 1 << LayerMask.NameToLayer("ShadowLadder") | (1 << LayerMask.NameToLayer("GreyBlock")) | (1 << LayerMask.NameToLayer("GreyLadder")));

        if (ghit && !uhit)
        {
            if (vspeed < 0)
            {
                if (!onGround)
                {
                    landingStamp       = 0f;
                    transform.position = ghit.point;
                }
                anim?.ResetTrigger("Jump");
                onGround = true;
            }
            vspeed = 0f;
        }

        if (vhit)
        {
            if (vspeed <= 0)
            {
                if (!onGround)
                {
                    landingStamp = 0f;
                }
                anim?.ResetTrigger("Jump");
                onGround           = true;
                transform.position = vhit.point;
            }
            else
            {
                transform.position = vhit.point + Vector2.down * col.size.y;
            }
            vspeed = 0f;
        }
        else
        {
            if (!Constants.NearZero(vspeed))
            {
                onGround = false;
            }
        }

        /// horizontal movement check
        ///
        var          h_range = transform.localScale.x * (hspeed < 0 ? col.size.x / 2 * -1 : col.size.x / 2);
        RaycastHit2D hhitl   =
            isLight ? Physics2D.Raycast(transform.position + Vector3.up * 3, Vector2.right, h_range, (1 << LayerMask.NameToLayer("LightBlock")) | (1 << LayerMask.NameToLayer("GreyBlock")))
            : Physics2D.Raycast(transform.position + Vector3.up * 3, Vector2.right, h_range, 1 << LayerMask.NameToLayer("ShadowBlock") | (1 << LayerMask.NameToLayer("GreyBlock")));

        RaycastHit2D hhitm =
            isLight ? Physics2D.Raycast(transform.position + Vector3.up * col.size.y / 2, Vector2.right, h_range, (1 << LayerMask.NameToLayer("LightBlock")) | (1 << LayerMask.NameToLayer("GreyBlock")))
            : Physics2D.Raycast(transform.position + Vector3.up * col.size.y / 2, Vector2.right, h_range, 1 << LayerMask.NameToLayer("ShadowBlock") | (1 << LayerMask.NameToLayer("GreyBlock")));

        RaycastHit2D hhitu =
            isLight ? Physics2D.Raycast(transform.position + Vector3.up * (col.size.y - 3), Vector2.right, h_range, (1 << LayerMask.NameToLayer("LightBlock")) | (1 << LayerMask.NameToLayer("GreyBlock")))
            : Physics2D.Raycast(transform.position + Vector3.up * (col.size.y - 3), Vector2.right, h_range, 1 << LayerMask.NameToLayer("ShadowBlock") | (1 << LayerMask.NameToLayer("GreyBlock")));

        if (!onLadder)
        {
            if (hhitl || hhitm || hhitu)
            {
                if (Constants.NearZero(vspeed) && Constants.NearZero(hspeed))
                {
                    if (hhitl && Constants.NearZero(hhitl.point.x - transform.position.x))
                    {
                        CheckOverlap();
                    }
                    else if (hhitm && Constants.NearZero(hhitm.point.x - transform.position.x))
                    {
                        CheckOverlap();
                    }
                    else if (hhitu && Constants.NearZero(hhitu.point.x - transform.position.x))
                    {
                        CheckOverlap();
                    }
                }

                if (!Constants.NearZero(hspeed))
                {
                    if (hhitl && !(onPush && hhitm.collider.gameObject.GetComponent <PushableBehaviour>()))
                    {
                        transform.position = new Vector3(hhitl.point.x + transform.localScale.x * col.size.x / 2 * Mathf.Sign(-hspeed), transform.position.y);
                    }
                    else if (hhitm && !(onPush && hhitm.collider.gameObject.GetComponent <PushableBehaviour>()))
                    {
                        transform.position = new Vector3(hhitm.point.x + transform.localScale.x * col.size.x / 2 * Mathf.Sign(-hspeed), transform.position.y);
                    }
                    else if (hhitu && !(onPush && hhitm.collider.gameObject.GetComponent <PushableBehaviour>()))
                    {
                        transform.position = new Vector3(hhitu.point.x + transform.localScale.x * col.size.x / 2 * Mathf.Sign(-hspeed), transform.position.y);
                    }
                }

                hspeed = 0f;
            }
            else
            {
                if (onPush)
                {
                    PushSlow = 1 / Mathf.Lerp(6, 3, 1 / (interact.size.x * interact.size.y));
                }
            }
        }

        hsum = hspeed;
        transform.position += Vector3.right * hsum * (onPush ? PushSlow : 1);

        #endregion

        col.enabled = true;

        #region LadderBehaviour

        RaycastHit2D lhit =
            isLight ? Physics2D.Raycast(transform.position + Vector3.up, Vector2.up, col.size.y + vspeed, (1 << LayerMask.NameToLayer("LightLadder")) | (1 << LayerMask.NameToLayer("GreyLadder")))
            : Physics2D.Raycast(transform.position + Vector3.up, Vector2.up, col.size.y + vspeed, 1 << LayerMask.NameToLayer("ShadowLadder") | (1 << LayerMask.NameToLayer("GreyLadder")));

        RaycastHit2D luhit =
            isLight ? Physics2D.Raycast(transform.position + Vector3.up * col.size.y / 2, Vector2.up, 1, (1 << LayerMask.NameToLayer("LightLadder")) | (1 << LayerMask.NameToLayer("GreyLadder")))
            : Physics2D.Raycast(transform.position + Vector3.up * col.size.y / 2, Vector2.up, 1, 1 << LayerMask.NameToLayer("ShadowLadder") | (1 << LayerMask.NameToLayer("GreyLadder")));

        RaycastHit2D lvhit =
            isLight ? Physics2D.Raycast(transform.position, Vector2.down, 1, (1 << LayerMask.NameToLayer("LightLadder")) | (1 << LayerMask.NameToLayer("GreyLadder")))
            : Physics2D.Raycast(transform.position, Vector2.down, 1, 1 << LayerMask.NameToLayer("ShadowLadder") | (1 << LayerMask.NameToLayer("GreyLadder")));

        if (lhit || lvhit)
        {
            ladderGrabbable = true;
        }
        else
        {
            ladderGrabbable = false;
        }

        if (!onLadder)
        {
            if (!Constants.NearZero(ladderGrabCall))
            {
                if (lhit && ladderGrabCall > 0)
                {
                    onGround           = false;
                    onLadder           = true;
                    transform.position = new Vector3(lhit.point.x + (lhit.point.x < 0 ? -8 - lhit.point.x % 16 : 8 - lhit.point.x % 16), transform.position.y);
                    anim?.SetTrigger("grabLadder");
                }
                else if (lvhit && ladderGrabCall < 0 && (ghit && !uhit))
                {
                    onGround           = false;
                    onLadder           = true;
                    transform.position = new Vector3(lvhit.point.x + (lvhit.point.x < 0 ? -8 - lvhit.point.x % 16 : 8 - lvhit.point.x % 16), transform.position.y - col.size.y / 2 - 2);
                    anim?.SetTrigger("grabLadder");
                }
                else if (lvhit && ladderGrabCall < 0 && !onGround)
                {
                    onGround           = false;
                    onLadder           = true;
                    transform.position = new Vector3(lvhit.point.x + (lvhit.point.x < 0 ? -8 - lvhit.point.x % 16 : 8 - lvhit.point.x % 16), transform.position.y);
                    anim?.SetTrigger("grabLadder");
                }
            }
        }
        else
        {
            if (!Constants.NearZero(ladderDropCall) && !(hhitl || hhitm || hhitu))
            {
                onLadder            = false;
                transform.position += Mathf.Sign(ladderDropCall) * Vector3.right * 12;
            }
            if (onGround)
            {
                landingStamp = 0f;
                anim?.ResetTrigger("Jump");
                onLadder = false;
                vspeed   = 0f;
            }
            if (!lhit && !lvhit)
            {
                onLadder = false;
            }
            if (vspeed > 0 && !luhit)
            {
                onLadder            = false;
                transform.position += Vector3.up * col.size.y / 2;
            }
        }

        #endregion

        transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, -3f);
        vsum = vspeed;
        hsum = hspeed;
    }
Beispiel #12
0
    // Update is called once per frame
    void Update()
    {
        //////          Controller Inputs         //////
        // (Those unused by OVR Character Controller //

        //// Axes ////

        //Right and left hand Hand Triggers
        float rPHTrig = OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, OVRInput.Controller.RTouch);
        float lPHTrig = OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, OVRInput.Controller.LTouch);

        //Right and left hand Index Triggers
        float rPITrig = OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, OVRInput.Controller.RTouch);
        float lPITrig = OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, OVRInput.Controller.LTouch);

        //Right Stick Vertical
        float rStickV = OVRInput.Get(OVRInput.Axis2D.PrimaryThumbstick, OVRInput.Controller.RTouch)[1];

        //// Buttons (GetDown not Get) ////

        //Right and left hand Thumb Rests
        bool rTTouch = OVRInput.Get(OVRInput.Touch.PrimaryThumbRest, OVRInput.Controller.RTouch);
        bool lTTouch = OVRInput.Get(OVRInput.Touch.PrimaryThumbRest, OVRInput.Controller.LTouch);


        //Right and Left hand Stick Buttons
        bool rTStickB = OVRInput.GetDown(OVRInput.Button.PrimaryThumbstick, OVRInput.Controller.RTouch);
        bool lTStickB = OVRInput.GetDown(OVRInput.Button.PrimaryThumbstick, OVRInput.Controller.LTouch);

        //Buttons
        bool A = OVRInput.GetDown(OVRInput.Button.One, OVRInput.Controller.RTouch);
        bool B = OVRInput.GetDown(OVRInput.Button.Two, OVRInput.Controller.RTouch);
        bool X = OVRInput.GetDown(OVRInput.Button.One, OVRInput.Controller.LTouch);
        bool Y = OVRInput.GetDown(OVRInput.Button.Two, OVRInput.Controller.LTouch);

        bool Start = OVRInput.GetDown(OVRInput.Button.Start, OVRInput.Controller.LTouch);


        bool rNearTouch = OVRInput.Get(OVRInput.NearTouch.PrimaryThumbButtons, OVRInput.Controller.RTouch);
        bool lNearTouch = OVRInput.Get(OVRInput.NearTouch.PrimaryThumbButtons, OVRInput.Controller.LTouch);


        //----------------------------------------//


        /////// Right hand Mini-Model Spinner///////
        if (rPHTrig == 1 && rPITrig == 1 && rNearTouch)
        {
            // Right Fist
            miniATT.SetActive(true);
        }
        else
        {
            miniATT.SetActive(false);
        }
        //-----------------------------------------//

        ////// Tool Tip toggling and animations //////

        if (lTStickB)
        {
            if (true)
            //if (!actionMenuPanel.activeInHierarchy)
            {
                // The tooltip toggle button should only be functional if the Action Menu is off
                if (!toolTipHolder.activeInHierarchy)
                {
                    // Default is off so on first click it should turn on
                    toolTipHolder.SetActive(true);
                }


                rayCastBool = !rayCastBool;
                if (rayCastBool)
                {
                    // It is time to raycast:
                    rayCastAnim.ResetTrigger("RayCastClose");
                    rayCastAnim.SetTrigger("RayCastOpen");
                    toolTipAnimator.ResetTrigger("ToolTipClose");
                    toolTipAnimator.SetTrigger("ToolTipOpen");
                }
                else
                {
                    // Stop raycasting
                    rayCastAnim.SetTrigger("RayCastClose");
                    rayCastAnim.ResetTrigger("RayCastOpen");
                    toolTipAnimator.ResetTrigger("ToolTipOpen");
                    toolTipAnimator.SetTrigger("ToolTipClose");
                }
            }
        }
        //if (actionMenuPanel.activeInHierarchy)
        //{
        //    //Action Menu is up: turn off tooltip functionality

        //    // prep rayCastBool for the next pass
        //    rayCastBool = false;
        //    // Run closing animations and prep for next trigger
        //    if (toolTipAnimator.enabled && toolTipAnimator.GetCurrentAnimatorStateInfo(0).IsName("ToolTipOpenIdle"))
        //    {
        //        rayCastAnim.SetTrigger("RayCastClose");
        //        rayCastAnim.ResetTrigger("RayCastOpen");
        //        toolTipAnimator.ResetTrigger("ToolTipOpen");
        //        toolTipAnimator.SetTrigger("ToolTipClose");
        //    }
        //}
        //---------------------------------------------------------//

        noSplits = GameObject.FindGameObjectsWithTag("Mini").Length == 0;

        if (B && noSplits)
        {
            GameObject splitPref = (GameObject)Instantiate(Resources.Load("SplitPrefab"));
            splitPref.transform.position = transform.position + new Vector3(0, .5f, 1);
        }


        ///// Player Controller Movements (Up-Down) //////
        float accel = GetComponent <OVRPlayerController>().Acceleration;

        transform.position += new Vector3(0, 10 * rStickV * accel * Time.deltaTime, 0);

        //--------------------------------------------------------//
    }
Beispiel #13
0
    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
    //
    //}

    //OnStateExit is called when a transition ends and the state machine finishes evaluating this state

    override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        animator.ResetTrigger("rangedAttack");
        animator.GetComponent <CombatCharacter>().IsAttacking = false;
    }
Beispiel #14
0
    void States()
    {
        switch (enemyStates)
        {
        case (EnemyStates.idle):
        {
            UpdateEnemyMaterial();

            an.SetBool("PlayerOnDistSiege", false);
            enemyStates = EnemyStates.idling;
            break;
        }

        case (EnemyStates.idling):
        {
            if (agent.isActiveAndEnabled)
            {
                agent.isStopped = true;
            }

            if (!canAct)
            {
                return;
            }
            if (IsPlayerOnSight())
            {
                if (GetDistanceFromPlayer() < minSiegeDist)
                {
                    timerHoldingStill = 0;
                    enemyStates       = EnemyStates.siege;
                }
                else
                {
                    enemyStates = EnemyStates.chase;
                }
            }
            else if (IsPlayerArround())
            {
                RotationToTarget();
            }

            break;
        }

        case (EnemyStates.siege):
        {
            MakeColliderOff();
            an.SetBool("PlayerOnDistSiege", true);
            timerHoldingStill = 0;
            enemyStates       = EnemyStates.sieging;
            rb.isKinematic    = true;
            if (agent.isActiveAndEnabled)
            {
                agent.isStopped = true;
            }


            break;
        }

        case (EnemyStates.sieging):
        {
            if (IsPlayerOnSight())
            {
                if (GetDistanceFromPlayer() > maxSiegeDist)
                {
                    timerHoldingStill += Time.deltaTime;

                    if (timerHoldingStill >= 1.5f)
                    {
                        timerHoldingStill = 0;
                        enemyStates       = EnemyStates.chase;
                    }
                }
                else if (GetDistanceFromPlayer() < siegeAttackDistance)
                {
                    if (playerHealth.health > 0)
                    {
                        enemyStates = EnemyStates.attack;
                    }
                    else
                    {
                        enemyStates = EnemyStates.idle;
                    }
                }
                else
                {
                    checkAttackSeconds += Time.deltaTime;

                    if (checkAttackSeconds >= 3)
                    {
                        if (playerHealth.health > 0)
                        {
                            enemyStates = EnemyStates.attack;
                        }
                        else
                        {
                            enemyStates = EnemyStates.idle;
                        }
                        checkAttackSeconds = 0;
                    }
                    else if (checkAttackSeconds % 2 == 0)
                    {
                        int rand = Random.Range(0, 5);

                        if (rand >= 3)
                        {
                            if (playerHealth.health > 0)
                            {
                                enemyStates = EnemyStates.attack;
                            }
                            else
                            {
                                enemyStates = EnemyStates.idle;
                            }
                        }
                    }
                }
                RotationToTarget();
                RotateAroundPlayer();
                an.SetFloat("Horizontal", rotateForce);
            }
            else
            {
                enemyStates = EnemyStates.searchPlayer;
            }

            break;
        }

        case (EnemyStates.chase):
        {
            rb.isKinematic  = true;
            agent.isStopped = false;
            UpdateEnemyMaterial();
            an.SetBool("PlayerOnDistSiege", false);
            an.Play("Walk", 0, 0);
            timerHoldingStill = 0;
            enemyStates       = EnemyStates.chasing;
            break;
        }

        case (EnemyStates.chasing):
        {
            if (IsPlayerOnSight())
            {
                if (GetDistanceFromPlayer() < minSiegeDist)
                {
                    enemyStates = EnemyStates.siege;
                }
                else
                {
                    RotationToTarget();
                    agent.SetDestination(playerTransform.position);
                }
            }
            else
            {
                enemyStates = EnemyStates.searchPlayer;
            }

            break;
        }

        case (EnemyStates.flinching):
        {
            //if (!an.GetCurrentAnimatorStateInfo(0).IsName("Standing React Large From Right") || !an.GetCurrentAnimatorStateInfo(0).IsName("Standing React Large From Left"))
            //{
            //    enemyStates = EnemyStates.idle;
            //}
            break;
        }

        case (EnemyStates.block):
        {
            an.ResetTrigger("Attack");
            an.SetTrigger("Blocking");

            UpdateEnemyMaterial();
            RotationToTarget();
            enemyStates = EnemyStates.blocking;
            break;
        }

        case (EnemyStates.blocking):
        {
            //MakeColliderOff();
            agent.velocity = Vector3.zero;

            break;
        }

        case (EnemyStates.attack):
        {
            if (playerHealth.health > 0)
            {
                if (GetWorse())
                {
                    int randWorse = Random.Range(0, 7);

                    if (randWorse == 0)
                    {
                        agent.velocity  = Vector3.zero;
                        agent.isStopped = true;
                        MakeColliderOff();
                        RotationToTarget();

                        int rand2 = Random.Range(0, 5);
                        if (rand2 == 2)
                        {
                            an.SetTrigger("HeavyAttack");
                            katanaCol.GetComponent <KatanaColliderEnemy>().isLightAttack = false;
                            enemyStates = EnemyStates.attackingPesado;
                        }
                        else
                        {
                            an.SetTrigger("Attack");
                            katanaCol.GetComponent <KatanaColliderEnemy>().isLightAttack = true;
                            enemyStates = EnemyStates.attacking;
                        }
                    }
                    else
                    {
                        enemyStates = EnemyStates.idle;
                    }
                }
                else
                {
                    agent.velocity  = Vector3.zero;
                    agent.isStopped = true;
                    MakeColliderOff();
                    RotationToTarget();

                    int rand = Random.Range(0, 5);
                    if (rand == 2)
                    {
                        an.SetTrigger("HeavyAttack");
                        katanaCol.GetComponent <KatanaColliderEnemy>().isLightAttack = false;
                        enemyStates = EnemyStates.attackingPesado;
                    }
                    else
                    {
                        an.SetTrigger("Attack");
                        katanaCol.GetComponent <KatanaColliderEnemy>().isLightAttack = true;
                        enemyStates = EnemyStates.attacking;
                    }
                }
            }
            else
            {
                enemyStates = EnemyStates.idle;
            }

            break;
        }

        case (EnemyStates.attackingPesado):
        {
            UpdateEnemyMaterial();
            //agent.velocity = Vector3.zero;
            //agent.isStopped = true;
            //enemyStates = EnemyStates.attacking;
            //an.SetTrigger("Attack");

            break;
        }

        case (EnemyStates.attacking):
        {
            //agent.velocity = Vector3.zero;
            //RotationToTarget();
            //RotationToTarget();

            break;
        }

        case (EnemyStates.searchPlayer):
        {
            timerMissing += Time.deltaTime;

            if (timerMissing >= timeMissingPlayer)
            {
                timerMissing = 0;
                enemyStates  = EnemyStates.returnToStart;
            }
            else
            {
                if (IsPlayerOnSight())
                {
                    timerMissing = 0;
                    enemyStates  = EnemyStates.chase;
                }
                else
                {
                    agent.SetDestination(lastPlayerPos);
                }
            }

            break;
        }

        case (EnemyStates.returnToStart):
        {
            if (IsPlayerOnSight())
            {
                enemyStates = EnemyStates.chase;
            }
            else if (transform.position == startPos)
            {
                enemyStates = EnemyStates.idle;
            }

            agent.SetDestination(startPos);

            break;
        }

        case (EnemyStates.death):
        {
            agent.velocity = Vector3.zero;
            break;
        }
        }
    }
 void EndAttack()
 {
     _isTriggered = false;
     Animator.ResetTrigger(AttackHash);
     UpdateParams();
 }
Beispiel #16
0
 private void Attack()
 {
     animator.ResetTrigger("HeadButt");
     animator.SetTrigger("HeadButt");
 }
 override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     shoot.GetComponent <ShowerAttack>().enabled = false;
     animator.ResetTrigger("Vulnerable");
 }
Beispiel #18
0
 public void FinishFade()
 {
     animator.ResetTrigger("FadeOutNoChange");
 }
Beispiel #19
0
    private void Update()
    {
        if (dead)
        {
            return;
        }

        /*  foreach (KeyCode kcode in Enum.GetValues(typeof(KeyCode)))
         * {
         *    if (Input.GetKeyDown(kcode))
         *        Debug.Log("KeyCode down: " + kcode);
         * }*/

        Vector3 right = cameraController.transform.right;

        right.y = 0.0f;
        right.Normalize();
        Vector3 forward = cameraController.transform.forward;

        forward.y = 0.0f;
        forward.Normalize();
        speed = 0.0f;
        Vector3 movement = Vector3.zero;

        bool haveMoved = false;


        if (Input.GetKey(leftKey) || Input.GetAxisRaw("MovementJoysticX") < -0.01)
        {
            speed     = walkingSpeed;
            movement  = -right;
            haveMoved = true;
        }
        if (Input.GetKey(rightKey) || Input.GetAxisRaw("MovementJoysticX") > 0.01)
        {
            speed     = walkingSpeed;
            movement  = right;
            haveMoved = true;
        }
        if (Input.GetKey(upKey) || Input.GetAxisRaw("MovementJoysticY") > 0.01)
        {
            speed     = walkingSpeed;
            movement  = movement + forward;
            haveMoved = true;
        }
        if (Input.GetKey(downKey) || Input.GetAxisRaw("MovementJoysticY") < -0.01)
        {
            speed     = walkingSpeed;
            movement  = movement - forward;
            haveMoved = true;
        }

        movement.Normalize();

        if ((Input.GetKey(runKey) || Input.GetKey(runGamePad)) && speed == walkingSpeed)
        {
            speed = runningSpeed;
        }

        if (((Input.GetKey(jumpKey) || Input.GetKey(jumpGamePad)) && onGround && !animator.GetBool("Crouch")) || onEnemy)
        {
            onEnemy = false;

            verticalSpeed = jumpSpeed;
            UpdateJumpComboState();
        }

        ///
        if ((Input.GetKey(crouchKey) || Input.GetKey(crouchGamePad)) && onGround)
        {
            animator.SetBool("Crouch", true);
        }
        else if ((Input.GetKeyUp(crouchKey) || Input.GetKeyUp(crouchGamePad)))
        {
            animator.SetBool("Crouch", false);
        }

        if ((Input.GetKey(crouchKey) || Input.GetKey(crouchGamePad)) && onGround && (Input.GetKey(jumpKey) || Input.GetKey(jumpGamePad)))
        {
            animator.SetBool("Crouch", true);
            animator.SetTrigger("Jump");
            verticalSpeed = longJumpSpeed;
        }

        if ((Input.GetKeyDown(punchKey) || Input.GetKeyDown(punchGamePad)) && animator.GetBool("Punch") == false)
        {
            animator.SetTrigger("Punch");
            animator.SetInteger("ComboPunch", CurrentComboPunch());
            currentComboTime = comboTime;
        }


        Quaternion desiredRotation = Quaternion.identity;

        if (movement != Vector3.zero)
        {
            desiredRotation = Quaternion.LookRotation(movement);
        }


        movement = movement * Time.deltaTime * movementSpeed * speed;

        verticalSpeed += Physics.gravity.y * Time.deltaTime;
        movement.y     = verticalSpeed * Time.deltaTime;


        collisionFlags = characterController.Move(movement);



        if (!haveMoved)
        {
            idleTimer -= Time.deltaTime;

            if (idleTimer <= 0)
            {
                isIdle = true;
            }
        }
        else
        {
            idleTimer = timeToIdle;
            isIdle    = false;
        }

        lastPosition = transform.position;

        if ((collisionFlags & CollisionFlags.Below) != 0)
        {
            verticalSpeed = -Physics.gravity.y * Time.deltaTime;
        }

        if (onWall)
        {
            animator.SetBool("onWall", true);

            onWallTimer -= Time.deltaTime;

            if ((Input.GetKey(jumpKey) || Input.GetKey(jumpGamePad)) && wallJumpEnabled == true)
            {
                verticalSpeed = jumpSpeed;
                UpdateJumpComboState();

                wallJumpEnabled = false;
            }
        }

        if (onWall && onWallTimer > 0)
        {
            if (!(Input.GetKey(jumpKey) || Input.GetKey(jumpGamePad)))
            {
                verticalSpeed = 0;
            }
        }
        else if (!onWall)
        {
            onWallTimer = onWallMaxTime;
            animator.SetBool("onWall", false);
        }



        if (speed == 0)
        {
            desiredRotation = transform.rotation;
        }

        transform.rotation = Quaternion.Lerp(transform.rotation, desiredRotation, lerpRotation * Time.deltaTime);

        animator.SetFloat("Speed", speed, 0.2f, Time.deltaTime);

        UpdateComboTime();

        if (onGround)
        {
            UpdateJumpComboTime();
            wallJumpEnabled = true;
            fallingTimer    = fallingTime;
            animator.ResetTrigger("Falling");
        }
        else
        {
            fallingTimer -= Time.deltaTime;

            if (fallingTimer <= 0.0f)
            {
                animator.SetTrigger("Falling");
                runParticles.SetActive(false);
                walkParticles.SetActive(false);
                groundParticles.SetActive(false);
            }
        }
        if (speed == runningSpeed && fallingTimer > 0)
        {
            runParticles.SetActive(true);
            walkParticles.SetActive(false);
            groundParticles.SetActive(false);
        }
        if (speed == walkingSpeed && fallingTimer > 0)
        {
            runParticles.SetActive(false);
            walkParticles.SetActive(true);
            groundParticles.SetActive(false);
        }
        if (speed == 0 && fallingTimer > 0)
        {
            runParticles.SetActive(false);
            walkParticles.SetActive(false);
            groundParticles.SetActive(false);
        }

        UpdateElevator();

        GravityUpdate();

        if (Input.GetMouseButtonDown(1))
        {
            GrabShell();
        }
    }
Beispiel #20
0
 public void Normalize()
 {
     CharAnimator.ResetTrigger("CharacterShrink");
     CharAnimator.SetTrigger("CharacterNormalize");
 }
Beispiel #21
0
    private IEnumerator OffPopAnim()
    {
        yield return(new WaitForSeconds(0.01f));

        animator.ResetTrigger("pop");
    }
Beispiel #22
0
    // Update is called once per frame
    void Update()
    {
        if (Input.GetKey(KeyCode.Escape))
        {
            escHeldFor += Time.deltaTime;

            if (escHeldFor >= 1f)
            {
                Application.Quit();
                Debug.Log("Quit...");
            }
        }

        if (Input.GetKeyUp(KeyCode.Escape))
        {
            escHeldFor = 0f;
            GameManager.Instance.ShowQuitHelp();
            Die();
        }

        float faceMove = 0.1f;
        float fx       = Mathf.PerlinNoise(Time.time * 0.5f, 0f) - 0.5f;
        float fy       = Mathf.PerlinNoise(Time.time * 0.5f, 1000f) - 0.5f;

        face.localPosition = facePos + new Vector3(fx * faceMove, fy * faceMove, 0);

        LetterSpawning();

        bool wasGrounded = grounded;

        if (!checkForEdges)
        {
            grounded = Physics2D.OverlapCircle(groundCheck.position, groundCheckRadius, groundLayer);

            // draw debug lines
            Color debugLineColor = grounded ? Color.green : Color.red;
            Debug.DrawLine(transform.position, groundCheck.position, debugLineColor, 0.2f);
            Debug.DrawLine(groundCheck.position + Vector3.left * groundCheckRadius, groundCheck.position + Vector3.right * groundCheckRadius, debugLineColor, 0.2f);
        }
        else
        {
            grounded = Physics2D.Raycast(transform.position, Vector2.down, 1f);

            // draw debug lines
            Color debugLineColor = grounded ? Color.green : Color.red;
            Debug.DrawRay(transform.position, Vector2.down, debugLineColor, 0.2f);
        }

        // just landed
        if (!wasGrounded && grounded)
        {
            Land();
        }

        // just left the ground
        if (wasGrounded && !grounded)
        {
            groundAngle = 0;
        }

        // jump buffer timing
        if (jumpBufferedFor > 0)
        {
            jumpBufferedFor -= Time.deltaTime;
        }

        // controls
        if (canControl)
        {
            float inputDirection = Input.GetAxis("Horizontal");

            // jump
            if ((grounded || (canDoubleJump && !doubleJumped)) && (Input.GetButtonDown("Jump") || jumpBufferedFor > 0))
            {
                body.velocity = new Vector2(body.velocity.x, 0);                  // reset vertical speed

                if (!grounded)
                {
                    doubleJumped = true;
                }

                jumpBufferedFor = 0;

                AudioManager.Instance.PlayEffectAt(0, transform.position);

                // jump sounds
                if (audioSource && jumpClip)
                {
                    audioSource.PlayOneShot(jumpClip);
                }

                // jump particles
                if (jumpParticles)
                {
                    GameObject                 go = Instantiate(jumpParticles, transform);
                    ParticleSystem             ps = go.GetComponent <ParticleSystem> ();
                    ParticleSystem.MainModule  mm = ps.main;
                    ParticleSystem.ShapeModule sm = ps.shape;

                    mm.startRotationZ = inputDirection * 0.4f;
                    sm.radius         = Random.Range(0.3f, 0.7f);
                    sm.radiusSpread   = Random.Range(0.1f, 0.4f);
                }

                // animation
                if (anim)
                {
                    anim.speed = 1f;
                    anim.SetTrigger("jump");
                    anim.ResetTrigger("land");
                }

                body.AddForce(Vector2.up * jump, ForceMode2D.Impulse);
            }
            else if (canControl && Input.GetButtonDown("Jump"))
            {
                // jump command buffering
                jumpBufferedFor = 0.2f;
            }

            // moving
            Vector2 moveVector = new Vector2(speed * inputDirection, body.velocity.y);

            if (Mathf.Sign(body.velocity.x) == Mathf.Sign(moveVector.x))
            {
                body.velocity = Vector2.MoveTowards(body.velocity, moveVector, acceleration);
            }
            else
            {
                body.velocity = moveVector;
            }

            // direction
            if (mirrorWhenTurning && Mathf.Abs(inputDirection) > inputBuffer)
            {
                float dir = Mathf.Sign(inputDirection);
                transform.localScale = new Vector2(dir, 1);

//				Transform sprite = transform.Find("Character");
//				Vector3 scl = sprite.localScale;
//				scl.x = dir;
//				sprite.localScale = scl;

//				transform.localEulerAngles = new Vector3(transform.localEulerAngles.x, 90f - dir * 90f, transform.localEulerAngles.z);
            }

            Vector2 p            = transform.position + Vector3.right * inputDirection * wallCheckDistance + Vector3.down * 0.5f;
            bool    wallHug      = Physics2D.OverlapCircle(p, groundCheckRadius, groundLayer);
            bool    wallHugTop   = Physics2D.OverlapCircle(p + Vector2.up * 1f, groundCheckRadius, groundLayer);
            Color   hugLineColor = grounded ? Color.green : Color.red;
            Debug.DrawLine(transform.position, p, hugLineColor, 0.2f);

            running = inputDirection <-inputBuffer || inputDirection> inputBuffer;

            if ((wallHug || wallHugTop) && !checkForEdges)
            {
                body.velocity = new Vector2(0, body.velocity.y);
                running       = false;
            }

            if (Physics2D.OverlapCircle(transform.position + Vector3.up * 0.5f, groundCheckRadius, groundLayer))
            {
                Die();
            }

            if (!grounded)
            {
                running = false;
            }

            if (anim)
            {
                anim.SetBool("running", running);

                if (running)
                {
                    anim.speed = Mathf.Abs(body.velocity.x * 0.18f);
                    anim.SetFloat("speed", Mathf.Abs(body.velocity.x));
                }
                else
                {
                    anim.speed = 1f;
                    anim.SetFloat("speed", 0);
                }
            }
        }
    }
    // Update is called once per frame
    void Update()
    {
        if (!animator)
        {
            return;
        }

        AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0);

        if (stateInfo.IsName("Base Layer.punch_21") || stateInfo.IsName("Base Layer.punch_22"))
        {
            ownPunch.SetActive(true);
            ownKick.SetActive(false);
        }
        else if (stateInfo.IsName("Base Layer.kick_21") || stateInfo.IsName("Base Layer.kick_24"))
        {
            ownPunch.SetActive(false);
            ownKick.SetActive(true);
        }
        else
        {
            ownPunch.SetActive(false);
            ownKick.SetActive(false);
        }

        if (photonView.isMine == false && PhotonNetwork.connected == true)
        {
            return;
        }

        //Si on est sur le sol
        if (stateInfo.IsName("Base Layer.Grounded"))
        {
            if (Input.GetButtonDown("Fire2"))
            {
                animator.SetTrigger("Kick");
                animator.ResetTrigger("Punch1");
                animator.ResetTrigger("Punch2");
                animator.ResetTrigger("Kick3");
            }
        }
        //Si on est sur le sol
        if (stateInfo.IsName("Base Layer.Grounded"))
        {
            if (Input.GetButtonDown("Fire1"))
            {
                animator.SetTrigger("Punch1");
                animator.ResetTrigger("Kick3");
                animator.ResetTrigger("Punch2");
                animator.ResetTrigger("Kick");
            }
        }
        //Faire un coup dans les airs
        if (stateInfo.IsName("Base Layer.punch_21"))
        {
            if (Input.GetButtonDown("Fire1"))
            {
                animator.SetTrigger("Punch2");
                animator.ResetTrigger("Punch1");
                animator.ResetTrigger("Kick3");
                animator.ResetTrigger("Kick");
            }
        }
        //Faire un coup dans les airs
        if (stateInfo.IsName("Base Layer.punch_22"))
        {
            if (Input.GetButtonDown("Fire2"))
            {
                animator.SetTrigger("Kick3");
                animator.ResetTrigger("Punch1");
                animator.ResetTrigger("Punch2");
                animator.ResetTrigger("Kick");
            }
        }
        //Donner un coup de pied sur le sol
        if (stateInfo.IsName("Base Layer.kick_21"))
        {
            animator.ResetTrigger("Kick3");
            animator.ResetTrigger("Punch1");
            animator.ResetTrigger("Punch2");
            animator.ResetTrigger("Kick");
        }
        //Donner un coup de pieds sur le sol
        if (stateInfo.IsName("Base Layer.kick_24"))
        {
            animator.ResetTrigger("Kick3");
            animator.ResetTrigger("Punch1");
            animator.ResetTrigger("Punch2");
            animator.ResetTrigger("Kick");
        }
    }
Beispiel #24
0
 public void OnExit()
 {
     _rb.velocity = new Vector2(0, 0);
     _animator.ResetTrigger("charging");
     hasFired = false;
 }
Beispiel #25
0
    void ShootArrow()
    {
        if (Input.GetButton("Fire1") & Time.time > nextFire & aiClass.bow.playerAmmo > 0)
        {
            drawTime   += 3 * Time.deltaTime;
            erroRanger -= 30 * Time.deltaTime;

            if (!bow.crossbow)
            {
                animator.SetTrigger("Draw");
            }
            else if (bow.crossbow)
            {
                animator.SetTrigger("DrawCrossbow");
            }
        }
        else if (Input.GetButtonUp("Fire1") & Time.time > nextFire & aiClass.bow.playerAmmo > 0)
        {
            nextFire = Time.time + fireRate;

            if (!bow.crossbow)
            {
                animator.SetTrigger("Loss");
                animator.ResetTrigger("Draw");
            }
            else if (bow.crossbow)
            {
                animator.SetTrigger("LossCrossbow");
                animator.ResetTrigger("DrawCrossbow");
            }

            if (drawTime < 5)
            {
                drawTime = 5f;
            }
            else if (drawTime != 10)
            {
                drawTime = 10;
            }

            if (erroRanger < 2)
            {
                erroRanger = 2f;
            }

            arrow.GetComponent <Arrow>().speed = drawTime;
            nextFire = Time.time + fireRate;
            angle    = shotSpawn.rotation;
            ShootingError();
            GameObject newArrow = Instantiate(arrow, shotSpawn.position, angle);
            newArrow.layer = LayerMask.NameToLayer("FriendlyFire");
            drawTime       = 0;
            erroRanger     = 30f;


            bow.UseAmmo();
        }
        else
        {
            drawTime = 0;
        }
    }
Beispiel #26
0
    private void Update()
    {
        switch (dir)
        {
        case 0:
            if (Input.GetKeyDown(KeyCode.RightArrow) || Input.GetKeyDown(KeyCode.D))
            {
                animator.SetTrigger("isCalled");
            }
            break;

        case 1:
            if (Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKeyDown(KeyCode.W))
            {
                animator.SetTrigger("isCalled");
            }
            break;

        case 2:
            if (Input.GetKeyDown(KeyCode.LeftArrow) || Input.GetKeyDown(KeyCode.A))
            {
                animator.SetTrigger("isCalled");
            }
            break;

        case 3:
            if (Input.GetKeyDown(KeyCode.DownArrow) || Input.GetKeyDown(KeyCode.S))
            {
                animator.SetTrigger("isCalled");
            }
            break;
        }

        if (lerpValue > 0 && lerpValue < 1 && animator.GetCurrentAnimatorStateInfo(0).IsName("Empty"))
        {
            gameObject.tag = "Moving Wall";
            tempTag        = gameObject.tag;
        }
        else
        {
            if (tempTag == "Moving Wall")
            {
                source.clip = push;
                source.Play();

                CameraShaker.Instance.ShakeOnce(2f, 5f, 0f, 0.2f);
            }
            gameObject.tag = "Untagged";
            tempTag        = gameObject.tag;
        }

        if (isAnim)
        {
            animator.ResetTrigger("isCalled");
            Vector2 tempSize = sprRen.size;
            tempSize.x  = Mathf.Lerp(startWidth, endWidth, lerpValue);
            sprRen.size = tempSize;

            Vector2 tempOff = col.offset;
            tempOff.x  = sprRen.size.x - startWidth + colOffset;
            col.offset = tempOff;

            Vector2 blurPos = blur.localPosition;
            blurPos.x          = sprRen.size.x - startWidth + blurPosX;
            blur.localPosition = blurPos;

            tempAnim = true;
        }
        else if (!isAnim)
        {
            if (tempAnim == true && lerpValue <= 0f)
            {
                source.clip = ready;
                source.Play();
                tempAnim = false;
            }
        }
    }
Beispiel #27
0
 // Use this for initialization
 void Start()
 {
     transform.position = new Vector3(0, GlobalVariables.playerDefHeight, 0);
     anim = GetComponent<Animator>();
     anim.ResetTrigger("TriggerHurt");
 }
Beispiel #28
0
    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    //{
    //
    //}

    // OnStateExit is called when a transition ends and the state machine finishes evaluating this state
    override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        Player.Instance.Attack = false;

        animator.ResetTrigger("attack");
    }
Beispiel #29
0
 //OnStateExit is called when a transition ends and the state machine finishes evaluating this state
 override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     animator.ResetTrigger("jump");
 }
Beispiel #30
0
 /// <summary>
 /// Ensures Portal enters neutal state
 /// </summary>
 public void SetNeutral()
 {
     anim.ResetTrigger("isBad");
     anim.ResetTrigger("isGood");
 }
 // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
 //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
 //
 //}
 // OnStateExit is called when a transition ends and the state machine finishes evaluating this state
 public override void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     Player.Instance.Jump = false;
     animator.ResetTrigger("jump");
 }
Beispiel #32
0
 void damageoff()    //ヒットボックスをインアクティブする
 {
     animator.ResetTrigger("damage");
     animator.SetInteger("state", 0);
 }
Beispiel #33
0
    private static void CarsContainerCheck(MoleculeContainer target, Animator animator, MoleculeCar[] cars)
    {
        foreach (var car in cars)
        {
            if (car.State == MoleculeCar.CarState.Waiting)
            {
                var carCargos = car.gameObject.GetComponentsInChildren<MoleculeCarCargo>();

                foreach (var cargo in carCargos)
                {
                    if (!cargo.IsLoaded && cargo.Formula == target.ContainerFormula && target.CollectCount > 5 && !target.IsAnimated)
                    {
                        /*
                        var go = (GameObject)Instantiate(ContainerPrefab, Vector3.zero, Quaternion.identity);
                        go.transform.parent = cargo.gameObject.transform;
                        go.transform.position = cargo.gameObject.transform.position;
                        go.transform.localPosition = Vector3.zero;
                        go.transform.localScale = Vector3.one * 0.001f;
                        */
                        target.IsAnimated = true;

                        target.gameObject.transform.parent = null;
                        var throwTo = target.gameObject.AddComponent<ThrowBehavior>();
                        throwTo.Projectile = target.gameObject.transform;
                        throwTo.Target = cargo.gameObject.transform;
                        throwTo.firingAngle = 45f;
                        var currentCar = car;
                        var currentCargo = cargo;
                        throwTo.AfterThrowAction = new Action(() =>
                        {
                            target.transform.parent = currentCargo.transform;
                            target.transform.position = currentCargo.gameObject.transform.position;
                            target.transform.localPosition = Vector3.zero;
                            target.transform.localScale = Vector3.one * 0.001f;
                            // target.Get(10);
                            currentCargo.IsLoaded = true;
                            if (!target.CanGet(1))
                            {
                                if (animator != null)
                                    animator.ResetTrigger(enoughsourcestrigger);
                            }

                            var stopPoint = GameObject.Find("StopPoint" + currentCar.Index);
                            var coin = stopPoint.GetComponentInChildren<MoleculeCoin>();
                            coin.BornCoin();
                        });
                    }
                }

            }
        }
    }
Beispiel #34
0
    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
    //
    //}

    // OnStateExit is called when a transition ends and the state machine finishes evaluating this state
    override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        Player.Instance.Dash = false;
        animator.ResetTrigger("dash");
        Player.Instance.EndDash();
    }
    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
    //
    //}

    // OnStateExit is called when a transition ends and the state machine finishes evaluating this state
    override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        Brawler.Instance.Attack = false;
        animator.ResetTrigger("attack");
        
    }
Beispiel #36
0
 /// <summary>
 /// Resets an animator trigger
 /// </summary>
 /// <param name="name">The name of the trigger</param>
 public void ResetTrigger(string name)
 {
     animator?.ResetTrigger(name);
 }
    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    //override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
    //
    //}

    // OnStateExit is called when a transition ends and the state machine finishes evaluating this state
    override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        Player.Instance.Attack = false;
        animator.ResetTrigger("uppercut");
        animator.ResetTrigger("throw");
    }
	void Start () {
		anim = GetComponent<Animator>();
		anim.SetTrigger("instructionOpen");
		anim.ResetTrigger("instructionClose");
	}
 public void ResetTrig()
 {
     myAnim.ResetTrigger("attack");
     myAnim.ResetTrigger("skillAttack");
 }
	// OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
	//override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
	//
	//}

	// OnStateExit is called when a transition ends and the state machine finishes evaluating this state
	override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
        Player.Instance.Slide = false;
        animator.ResetTrigger("slide");
	}
 void OnEnterHit()
 {
     anim.ResetTrigger("Hit");
 }
	// OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
	//override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
	//
	//}

	// OnStateExit is called when a transition ends and the state machine finishes evaluating this state
	override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
        animator.GetComponent<Character>().Attack = false;
        animator.ResetTrigger("attack");
        animator.ResetTrigger("throw");
    }
    void Update()
    {
        spriteRenderer.sortingOrder = Mathf.RoundToInt(transform.position.x - 0.9f) + Mathf.RoundToInt(transform.position.y - 0.9f);

        //-------------------RAYCASTS-------------------

        Vector2 groundRaycast = new Vector2(0, -0.25f);
        Vector2 groundCheckRaycastShort;
        Vector2 groundCheckRaycastLong;
        Vector2 wallAboveRaycast = new Vector2(0, 0.5f);
        Vector2 grabRaycast;
        Vector2 dropRaycast;
        Vector2 bodyRaycast;

        if (isForward)
        {
            groundCheckRaycastShort = new Vector2(1.1f, -0.25f);
            groundCheckRaycastLong  = new Vector2(1.5f, -0.25f);
            grabRaycast             = new Vector2(0.6f, 0.8f);
            dropRaycast             = new Vector2(-0.5f, 0);
            bodyRaycast             = new Vector2(0.3f, 0);
        }
        else
        {
            groundCheckRaycastShort = new Vector2(-1.1f, -0.25f);
            groundCheckRaycastLong  = new Vector2(-1.5f, -0.25f);
            grabRaycast             = new Vector2(-0.6f, 0.8f);
            dropRaycast             = new Vector2(0.5f, 0);
            bodyRaycast             = new Vector2(-0.3f, 0);
        }


        RaycastHit2D feet            = Physics2D.Raycast(groundCheck.position, Vector2.down, Mathf.Abs(groundRaycast.y), 1 << 8);
        RaycastHit2D feetGroundShort = Physics2D.Raycast(groundCheck.position, groundCheckRaycastShort, Mathf.Abs(Pythagoras(groundCheckRaycastShort.x, groundCheckRaycastShort.y)), 1 << 8);
        RaycastHit2D feetGroundLong  = Physics2D.Raycast(groundCheck.position, groundCheckRaycastLong, Mathf.Abs(Pythagoras(groundCheckRaycastLong.x, groundCheckRaycastLong.y)), 1 << 8);
        RaycastHit2D wallAboveCheck  = Physics2D.Raycast(grabCheck.position, Vector2.up, Mathf.Abs(wallAboveRaycast.y), 1 << 9);
        RaycastHit2D body            = Physics2D.Raycast(bodyCheck.position, bodyRaycast, Mathf.Abs(bodyRaycast.x), 1 << 9);
        RaycastHit2D exitCheck       = Physics2D.Raycast(bodyCheck.position, bodyRaycast, Mathf.Abs(bodyRaycast.x));
        RaycastHit2D hands           = Physics2D.Raycast(grabCheck.position, grabRaycast, Mathf.Abs(Pythagoras(grabRaycast.x, grabRaycast.y)), 1 << 10);
        RaycastHit2D handsDrop       = Physics2D.Raycast(groundCheck.position, dropRaycast, Mathf.Abs(dropRaycast.x), 1 << 10);


        //-------------------GROUND CHECK-------------------

        if (feet.collider == null)
        {
            if (isJumping || isJumpingUp || isCrouching || isClimbing || isDescending || isWinning || animator.GetCurrentAnimatorStateInfo(0).IsName("StandingJump") || animator.GetCurrentAnimatorStateInfo(0).IsName("RunningJump"))
            {
                ;
            }
            else if (isRunning || !isRunning)
            {
                isGrounded = false;
                animator.SetBool("Falling", true);
                if (!animator.GetCurrentAnimatorStateInfo(0).IsName("ToFalling") && !animator.GetCurrentAnimatorStateInfo(0).IsName("Falling"))
                {
                    animator.Play("ToFalling");
                }
            }
            else
            {
                isGrounded = false;
                animator.SetBool("Falling", true);
                animator.Play("ToFalling");
            }

            if (isForward && !isJumpingUp && !isClimbing && !isDescending && !isWinning && !animator.GetCurrentAnimatorStateInfo(0).IsName("StandingJump") && !animator.GetCurrentAnimatorStateInfo(0).IsName("RunningJump"))
            {
                if (body.collider == null)
                {
                    rb.velocity = new Vector2(fallingMomentum, rb.velocity.y);
                }
                else
                {
                    rb.velocity = new Vector2(0, rb.velocity.y);
                }
            }
            else if (!isForward && !isJumpingUp && !isClimbing && !isDescending && !isWinning && !animator.GetCurrentAnimatorStateInfo(0).IsName("StandingJump") && !animator.GetCurrentAnimatorStateInfo(0).IsName("RunningJump"))
            {
                if (body.collider == null)
                {
                    rb.velocity = new Vector2(-fallingMomentum, rb.velocity.y);
                }
                else
                {
                    rb.velocity = new Vector2(0, rb.velocity.y);
                }
            }

            /*isGrounded = false;
             * animator.SetBool("Falling", true);
             *
             * if (isJumping)
             * {
             *  isGrounded = true;
             *  animator.SetBool("Falling", false);
             * }
             * if (isCrouching)
             * {
             *  isCrouching = false;
             *  animator.Play("ToFalling");
             * }
             * else if (isRunning)
             * {
             *  isRunning = false;
             *  fallingMomentum = rb.velocity.x;
             *  animator.Play("ToFalling");
             * }
             * else if (rb.gravityScale != 0 && animator.GetCurrentAnimatorStateInfo(0).IsName("StandingJump") || rb.gravityScale != 0 && animator.GetCurrentAnimatorStateInfo(0).IsName("RunningJump"))
             * {
             *  if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.6f)
             *      animator.Play("ToFalling");
             * }*/
        }
        else if (LayerMask.LayerToName(feet.collider.gameObject.layer) == "Ground")
        {
            if (animator.GetCurrentAnimatorStateInfo(0).IsName("Falling"))
            {
                Debug.Log("Time in air: " + animator.GetCurrentAnimatorStateInfo(0).normalizedTime);
                if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime < 35)
                {
                    isGrounded = true;
                    animator.SetBool("Falling", false);
                    //fallingMomentum = 0;

                    Footstep();
                }
                else if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime >= 35 && animator.GetCurrentAnimatorStateInfo(0).normalizedTime < 50)
                {
                    heroHP -= 1;

                    hurtFlash.enabled = true;
                    Invoke("HurtFlash", hurtTime);

                    if (heroHP <= 0)
                    {
                        isGrounded           = true;
                        isDead               = true;
                        spriteRenderer.flipX = false;
                        animator.SetTrigger("Die");
                        //animator.SetBool("Falling", false);
                        audioSource.pitch  = 1;
                        audioSource.volume = 1;
                        audioSource.PlayOneShot(fallDeath);
                        //fallingMomentum = 0;
                        CantMove();
                    }
                    else
                    {
                        isGrounded = true;
                        animator.SetBool("Falling", false);
                        audioSource.pitch  = 1;
                        audioSource.volume = 1;
                        audioSource.PlayOneShot(fallHurt);
                        //fallingMomentum = 0;
                        CantMove();

                        animator.SetBool("Crouch", true);
                        Invoke("FallHurt", 2);
                    }
                }
                else if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime >= 50)
                {
                    heroHP = 0;

                    hurtFlash.enabled = true;
                    Invoke("HurtFlash", hurtTime);

                    isGrounded           = true;
                    isDead               = true;
                    spriteRenderer.flipX = false;
                    animator.SetTrigger("Die");
                    //animator.SetBool("Falling", false);
                    audioSource.pitch  = 1;
                    audioSource.volume = 1;
                    audioSource.PlayOneShot(fallDeath);
                    //fallingMomentum = 0;
                    CantMove();
                }
            }
        }


        //-------------------GRAB CHECK-------------------

        if (hands.collider == null)
        {
            ;
        }
        else if (LayerMask.LayerToName(hands.collider.gameObject.layer) == "Grab")
        {
            ;//Debug.Log("Works + " + hands.collider.gameObject.name);
        }
        Debug.DrawRay(groundCheck.position, groundRaycast, Color.red);
        Debug.DrawRay(groundCheck.position, groundCheckRaycastShort, Color.blue);
        Debug.DrawRay(groundCheck.position, groundCheckRaycastLong, Color.red);
        Debug.DrawRay(grabCheck.position, wallAboveRaycast, Color.magenta);
        Debug.DrawRay(bodyCheck.position, bodyRaycast, Color.white);
        Debug.DrawRay(grabCheck.position, grabRaycast, Color.red);
        Debug.DrawRay(groundCheck.position, dropRaycast, Color.yellow);


        //-------------------MOVEMENT-------------------

        if (Input.GetKeyDown("r"))
        {
            /*if (isDead)
             * {*/
            rb.transform.position = new Vector2(-14.5f, 2);              //DEBUG
            heroHP = 3;
            animator.ResetTrigger("Die");
            animator.Play("Standing");
            spriteRenderer.flipX = false;
            isForward            = true;
            isJumping            = false;
            isJumpingUp          = false;
            isDead          = false;
            rb.gravityScale = 1;
            CanMove();
            //}
        }

        if (Input.GetKeyDown("escape"))
        {
            QuitGame();
        }

        if (animator.GetBool("canMove"))                        //try to leave inputs here and move behaviour to fixedupdate
        {
            //-------------------RIGHT-------------------

            if (Input.GetKey("right") && !Input.GetKey("left shift") && isGrounded)
            {
                if (!isCrouching && !animator.GetCurrentAnimatorStateInfo(0).IsName("CrouchMove") && !animator.GetCurrentAnimatorStateInfo(0).IsName("Crouch"))
                {
                    if (!isForward)
                    {
                        animator.SetTrigger("Turn");
                    }
                    else
                    {
                        animator.SetBool("Running", true);
                        rb.velocity = new Vector2(runSpeed, rb.velocity.y);
                        isRunning   = true;

                        if (Input.GetKey("down"))
                        {
                            isRunning = false;
                            animator.Play("ToCrouch");

                            animator.SetBool("Crouch", true);
                            isCrouching = true;
                        }
                        else if (Input.GetKeyDown("up"))
                        {
                            animator.SetTrigger("Jump");
                        }


                        //spriteRenderer.flipX = false;
                    }
                }
                else if (isCrouching)
                {
                    if (isForward)
                    {
                        animator.SetTrigger("Step");
                        rb.velocity = new Vector2(crouchSpeed, rb.velocity.y);

                        if (animator.GetCurrentAnimatorStateInfo(0).IsName("CrouchMove"))
                        {
                            animator.ResetTrigger("Step");
                        }

                        if (Input.GetKeyUp("down"))
                        {
                            animator.SetBool("Crouch", false);
                            isCrouching = false;
                        }
                    }
                }
            }


            //-------------------LEFT-------------------

            else if (Input.GetKey("left") && !Input.GetKey("left shift") && isGrounded)
            {
                if (!isCrouching && !animator.GetCurrentAnimatorStateInfo(0).IsName("CrouchMove") && !animator.GetCurrentAnimatorStateInfo(0).IsName("Crouch"))
                {
                    if (isForward)
                    {
                        animator.SetTrigger("Turn");
                    }
                    else
                    {
                        animator.SetBool("Running", true);
                        rb.velocity = new Vector2(-runSpeed, rb.velocity.y);
                        isRunning   = true;

                        if (Input.GetKey("down"))
                        {
                            isRunning = false;
                            animator.Play("ToCrouch");

                            animator.SetBool("Crouch", true);
                            isCrouching = true;
                        }
                        else if (Input.GetKeyDown("up"))
                        {
                            animator.SetTrigger("Jump");
                        }

                        //spriteRenderer.flipX = true;
                    }
                }
                else if (isCrouching)
                {
                    if (!isForward)
                    {
                        animator.SetTrigger("Step");
                        rb.velocity = new Vector2(-crouchSpeed, rb.velocity.y);

                        if (animator.GetCurrentAnimatorStateInfo(0).IsName("CrouchMove"))
                        {
                            animator.ResetTrigger("Step");
                        }

                        if (Input.GetKeyUp("down"))
                        {
                            animator.SetBool("Crouch", false);
                            isCrouching = false;
                        }
                    }
                }
            }


            //-------------------UP-------------------

            else if (Input.GetKeyDown("up") && !isRunning && !isClimbing)
            {
                if (exitCheck.collider == null || exitCheck.collider.tag != "Exit")
                {
                    if (wallAboveCheck.collider != null)
                    {
                        animator.SetTrigger("JumpWallAbove");
                    }
                    else
                    {
                        animator.SetTrigger("Jump");

                        if (hands.collider == null)
                        {
                            ;
                        }
                        else if (LayerMask.LayerToName(hands.collider.gameObject.layer) == "Grab" && !isClimbing)
                        {
                            //Debug.Log("Can grab");

                            if (isForward)
                            {
                                rb.position = new Vector2(hands.collider.gameObject.transform.position.x - 0.3f, rb.position.y);
                            }
                            else if (!isForward)
                            {
                                rb.position = new Vector2(hands.collider.gameObject.transform.position.x + 0.3f, rb.position.y);
                            }

                            isGrounded = false;
                            isClimbing = true;
                            animator.SetBool("Grip", true);
                        }
                    }
                }
                else if (exitCheck.collider.tag == "Exit" && !isCrouching)
                {
                    CantMove();
                    isWinning             = true;
                    rb.gravityScale       = 0;
                    spriteRenderer.flipX  = false;
                    rb.transform.position = new Vector2(exitCheck.collider.transform.position.x, exitCheck.collider.transform.position.y - 0.3f);
                    animator.SetTrigger("Win");

                    foreach (Transform child in exitCheck.transform)
                    {
                        child.GetComponent <Renderer>().sortingLayerName = "Foreground";
                    }
                }
            }

            else if (Input.GetKey("up") && isClimbing)
            {
                if (animator.GetCurrentAnimatorStateInfo(0).IsName("HangingWall") || animator.GetCurrentAnimatorStateInfo(0).IsName("Swinging") || animator.GetCurrentAnimatorStateInfo(0).IsName("SwingingSecond"))
                {
                    animator.SetTrigger("Climb");
                }
            }

            else if (!Input.GetKey("up") && !Input.GetKey("left shift") && isClimbing && !isDescending)
            {
                isClimbing = false;
                animator.SetBool("Grip", false);
            }

            /*else if (Input.GetKey("up") && isClimbing || Input.GetKey("left shift") && isClimbing)
             * {
             *  animator.SetBool("Grip", true);
             *  //rb.gravityScale = 0;
             *  if (!Input.GetKey("up") && !Input.GetKey("left shift"))
             *  {
             *      animator.SetBool("Grip", false);
             *      animator.ResetTrigger("Jump");
             *      isClimbing = false;
             *      //rb.gravityScale = 1;
             *  }
             * }*/


            //-------------------DOWN-------------------

            else if (Input.GetKey("down") && isGrounded && !isRunning)
            {
                if (handsDrop.collider == null)
                {
                    animator.SetBool("Crouch", true);
                    isCrouching = true;
                }
                else if (LayerMask.LayerToName(handsDrop.collider.gameObject.layer) == "Grab" && !animator.GetCurrentAnimatorStateInfo(0).IsName("Descending"))
                {
                    if (isForward)
                    {
                        rb.position = new Vector2(handsDrop.collider.gameObject.transform.position.x + 0.1f, rb.position.y);
                    }
                    else if (!isForward)
                    {
                        rb.position = new Vector2(handsDrop.collider.gameObject.transform.position.x - 0.15f, rb.position.y);
                    }

                    isGrounded   = false;
                    isClimbing   = true;
                    isDescending = true;
                    animator.SetTrigger("Descend");
                    animator.SetBool("Grip", true);
                }
            }


            //-------------------SHIFT-------------------

            else if (Input.GetKey("left shift") && isGrounded && !isRunning)
            {
                if (Input.GetKeyDown("right"))
                {
                    if (isForward)
                    {
                        animator.SetTrigger("Step");
                        //rb.velocity = new Vector2(runSpeed, rb.velocity.y);
                    }
                    else
                    {
                        animator.SetTrigger("Turn");
                    }
                }
                else if (Input.GetKeyDown("left"))
                {
                    if (!isForward)
                    {
                        animator.SetTrigger("Step");
                        //rb.velocity = new Vector2(-runSpeed, rb.velocity.y);
                    }
                    else
                    {
                        animator.SetTrigger("Turn");
                    }
                }
            }
            else
            {
                animator.SetBool("Running", false);
                animator.SetBool("Crouch", false);
                animator.ResetTrigger("Step");
                animator.ResetTrigger("Jump");
                animator.ResetTrigger("JumpWallAbove");
                isRunning   = false;
                isCrouching = false;
                //isClimbing = false;

                if (isGrounded)
                {
                    CanMove();
                }
            }
        }

        if (isCrouching)
        {
            //GetComponent<CapsuleCollider2D>().size;
        }
    }
Beispiel #44
0
 public override void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     base.OnStateExit(animator, stateInfo, layerIndex);
     animator.ResetTrigger(exit);
 }
Beispiel #45
0
 public override void OnSLStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     animator.ResetTrigger(AlbinoDragonBehavior.BasicAttack);
     animator.ResetTrigger(AlbinoDragonBehavior.ClawAttack);
     animator.ResetTrigger(AlbinoDragonBehavior.FlameAttack);
 }
 public void ResetFireTrigger()
 {
     animator.ResetTrigger("FireProjectile");
 }
Beispiel #47
0
 // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
 public override void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
 {
     animator.ResetTrigger("atacarmele");
 }