Beispiel #1
0
    private void CheckIfTouchingValidGround()
    {
        colliderGround    = Physics2D.OverlapCapsule(isTouchingGroundedChecker.position, capsuleSize, CapsuleDirection2D.Horizontal, 0, groundLayer);
        colliderWallLeft  = Physics2D.OverlapCircle(isTouchingWallLeftChecker.position, checkGroundRadius, groundLayer);
        colliderWallRight = Physics2D.OverlapCircle(isTouchingWallRightChecker.position, checkGroundRadius, groundLayer);
        if (colliderGround != null)
        {
            isGrounded = true;
        }
        else
        {
            isGrounded = false;
        }

        if (colliderWallLeft != null)
        {
            isTouchingLeftWall = true;
        }
        else
        {
            isTouchingLeftWall = false;
        }

        if (colliderWallRight != null)
        {
            isTouchingRightWall = true;
        }
        else
        {
            isTouchingRightWall = false;
        }
    }
Beispiel #2
0
    public bool IsGrounded()
    {
        float      extraHeight = 0.1f;
        Collider2D col         = Physics2D.OverlapCapsule(new Vector2(MainCollider.transform.position.x, MainCollider.transform.position.y - extraHeight), MainCollider.size, CapsuleDirection2D.Vertical, 0, PlatformLayer);

        return(col != null);
    }
        // return the resulting ground gameobject
        private GroundedStates GroundedCheck()
        {
            // perform a capsule overlap of the same size as the player's collider, but slightly below the player
            Vector2 capsuleOverlapPoint = new Vector2(coll2D.bounds.center.x, coll2D.bounds.center.y - groundedCheckOffset);

            Collider2D result = Physics2D.OverlapCapsule(capsuleOverlapPoint, coll2D.size, coll2D.direction, 0, LayerMask.GetMask("World"));

            if (result != null)
            {
                if (result.gameObject.CompareTag("JumpBoost"))
                {
                    return(GroundedStates.BoostGround);
                }
                else if (result.gameObject.CompareTag("NoJump"))
                {
                    return(GroundedStates.None);
                }
                else
                {
                    return(GroundedStates.Ground);
                }
            }
            else
            {
                return(GroundedStates.None);
            }
        }
Beispiel #4
0
    private void CheckIfTouchingDeathGround()
    {
        colliderGround    = Physics2D.OverlapCapsule(isTouchingGroundedChecker.position, capsuleSize, CapsuleDirection2D.Horizontal, 0, deathLayer);
        colliderWallLeft  = Physics2D.OverlapCircle(isTouchingWallLeftChecker.position, checkGroundRadius, deathLayer);
        colliderWallRight = Physics2D.OverlapCircle(isTouchingWallRightChecker.position, checkGroundRadius, deathLayer);

        colliderCrushed = Physics2D.OverlapCircle(isCrushedChecker.position, checkGroundRadius, groundLayer);

        if ((colliderGround != null) || (colliderWallLeft != null) || (colliderWallRight != null) || (colliderCrushed != null))
        {
            //Debug.Log(rigidbody2DPlayer.transform.position.ToString());
            Vector2 temp = spawnPoint.transform.position;
            rigidbody2DPlayer.transform.position = temp;
            rigidbody2DPlayer.velocity           = Vector2.zero;
            deathFlag = true;
        }
        else if (deathFlag)
        {
            deathFlag = false;
            deaths++;
            PlayerPrefs.SetInt("Deaths", PlayerPrefs.GetInt("Deaths", 0) + 1);
            //Debug.Log("Deaths: " + deaths.ToString());
            deathsText.text = Convert.ToString(deaths, 2);
            audioSource.PlayOneShot(audioDeath, audioVolume * (audioVolumeGlobal / 100.0f));
            //Debug.Log(rigidbody2DPlayer.position.ToString());
        }
    }
Beispiel #5
0
    public int AttackDir(Vector2 dir)
    {
        if (!IsCanDamage || nextDamageTimer > 0)
        {
            return(0);
        }
        nextDamageTimer = damageRate;

        m_DamagerTransform = (Vector2)transform.position + size / 2 * dir;
        angle = Vector2.SignedAngle(Vector2.right, dir);
        int hitCount = Physics2D.OverlapCapsule(m_DamagerTransform,
                                                size, CapsuleDirection2D.Horizontal, angle, m_AttackContactFilter, m_AttackOverlapResults);

        //Debug.Log("Damage : " + m_DamagerTransform + "; angle" + angle + " , hitCount : " + hitCount);
        for (int i = 0; i < hitCount; i++)
        {
            m_LastHit = m_AttackOverlapResults[i];
            Damageable damageable = m_LastHit.GetComponentInParent <Damageable>();
            if (damageable)
            {
                damageable.TakeDamage(this, ignoreInvincibility);
                //OnDamageableHit.Invoke(this, damageable);
                //if (disableDamageAfterHit)
                //    DisableDamage();
            }
        }

        //OnNonDamageableHit.Invoke(this);
        return(hitCount);
    }
Beispiel #6
0
    private void FixedUpdate()
    {
        ForceX   = Mathf.Abs(ForceX) < 4 ? 0 : Mathf.Sign(ForceX) * (Mathf.Abs(ForceX) - gravityScale * windFriction / 2);
        ForceY   = Mathf.Abs(ForceY) < 4 ? 0 : Mathf.Sign(ForceY) * (Mathf.Abs(ForceY) - gravityScale * windFriction);
        grounded = Physics2D.OverlapCapsule(groundCheck.position, new Vector2(0.5f, 1.5f), CapsuleDirection2D.Vertical, 0, whatIsGround);

        bool IsSlope = Physics2D.OverlapCapsule(groundCheck.position, new Vector2(0.5f, 1.5f), CapsuleDirection2D.Vertical, 0, whatIsSlope);

        animator.SetBool("IsSlope", IsSlope);

        if (playerAction == PlayerAction.ClimbingUp)
        {
            rgdb.velocity = new Vector2(ClimbingVelocityX, ClimbingVelocityY);
        }
        else if (playerAction == PlayerAction.HangUp)
        {
            rgdb.velocity = new Vector2(ForceX, move.y * ropeSpeed);
        }
        else
        {
            rgdb.velocity = new Vector2(move.x * maxSpeed + ForceX, rgdb.velocity.y + ForceY);
        }

        //If it is hanged on the rope and has no energy, the player falls
        if (energyController.GetCurrentEnergy() <= energyController.GetEnergyRecoverySpeed())
        {
            animator.Play("Falling");
            playerAction = PlayerAction.Falling;
            setNeutralState();
        }
    }
Beispiel #7
0
    private void Update()
    {
        var pointPlayer = new Vector2(transform.position.x, transform.position.y);
        var sizePlayer  = new Vector2(0.9f, 5.4f);//the size of the capsule collider of the player. This is not perfect.

        //bool isOverlappingFrontLayer = Physics2D.OverlapCapsule(playerPosition, playerHeight, CapsuleDirection2D.Vertical, playerEulerAngleZ, frontLayerMask) != null;
        bool isOverlappingFrontLayer = Physics2D.OverlapCapsule(pointPlayer, sizePlayer, CapsuleDirection2D.Vertical, 0, frontLayer) != null;
        bool isOverlappingBackLayer  = Physics2D.OverlapCapsule(pointPlayer, sizePlayer, CapsuleDirection2D.Vertical, 0, backLayer) != null;

        //Change plane

        if (Input.GetButtonDown("ChangePlane"))
        {
            if (!isOverlappingFrontLayer && !isOverlappingBackLayer)
            {
                SwitchAvatar();
            }
            //SwitchAvatar();
        }
        //if the position change is in the switch() it does not work properly
        if (whichAvatarIsOn == 2)
        {
            transform.position = new Vector3(transform.position.x, transform.position.y, 1);
        }
        else
        {
            transform.position = new Vector3(transform.position.x, transform.position.y, -1);
        }
    }
Beispiel #8
0
 // Update is called once per frame
 void Update()
 {
     if (poisonCheck)
     {
         --poison;
         if (poison <= 0)
         {
             poison = 15;
             --PlayerStats.Health;
         }
     }
     if (PlayerStats.Health <= 0)
     {
         SceneManager.LoadScene(0);
     }
     Playermove();
     isGrounded = Physics2D.OverlapCapsule(groundCheck.position, new Vector2(1f, 1f), CapsuleDirection2D.Horizontal, 0, groundMask);
     if (SceneManager.GetActiveScene().name == "level1")
     {
         gameObject.SetActive(true);
     }
     else if (SceneManager.GetActiveScene().name == "RPGScene")
     {
         gameObject.SetActive(false);
     }
 }
Beispiel #9
0
    private bool IsGrounded()
    {
        float      extraHeight = 0.2f;
        Collider2D col         = Physics2D.OverlapCapsule(new Vector2(MainCollider.transform.position.x, MainCollider.transform.position.y - extraHeight),
                                                          new Vector2(MainCollider.size.x - 0.2f, MainCollider.size.y), CapsuleDirection2D.Vertical, 0, worldLayer);

        return(col != null);
    }
Beispiel #10
0
        private void AttackSlash()
        {
            Collider2D hit = Physics2D.OverlapCapsule(slashPos.position, slashRange, CapsuleDirection2D.Horizontal, slashAngle, playerMask);

            if (hit)
            {
                object[] package = new object[1];
                package[0] = DamageSlash;
                hit.SendMessage("TakeDamage", package);
            }
        }
Beispiel #11
0
    private bool CheckSideCollision()
    {
        Collider2D colliderCheck = Physics2D.OverlapCapsule(coll.bounds.center, new Vector2(coll.size.x * wallJumpDetectionSizeMod, coll.size.y * 0.9f), CapsuleDirection2D.Vertical, 0f, jumpMask);

        if (colliderCheck)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
Beispiel #12
0
    public Collider2D CanDropThrough()
    {
        Collider2D colliderCheck = Physics2D.OverlapCapsule(coll.bounds.center + Vector3.down * jumpCastOffset, new Vector2(coll.size.x * 0.9f, coll.size.y * 0.9f), CapsuleDirection2D.Vertical, 0f, jumpMask);

        if (!falling && !frozen && colliderCheck && colliderCheck.CompareTag("DropThrough"))
        {
            if (currentState == State.Idle || currentState == State.Walk)
            {
                return(colliderCheck);
            }
        }
        return(null);
    }
Beispiel #13
0
    bool CheckGrounded()
    {
        Collider2D colliderCheck = Physics2D.OverlapCapsule(coll.bounds.center + Vector3.down * 0.1f, new Vector2(coll.size.x * 0.9f, coll.size.y * 0.9f), CapsuleDirection2D.Vertical, 0f, groundMask);

        if (colliderCheck)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
Beispiel #14
0
    private bool CheckGrounded()
    {
        Collider2D colliderCheck = Physics2D.OverlapCapsule(coll.bounds.center + Vector3.down * jumpCastOffset, new Vector2(coll.size.x * 0.9f, coll.size.y * 0.9f), CapsuleDirection2D.Vertical, 0f, jumpMask);

        if (colliderCheck)
        {
            return(true);
        }
        else
        {
            return(false);
        }
        //return Physics.CheckCapsule (coll.bounds.center, new Vector3 (coll.bounds.center.x, coll.bounds.min.y, coll.bounds.center.z), coll.bounds.extents.x - 1f, jumpMask);
    }
Beispiel #15
0
        /// <summary>
        /// Fires the laser towards the enemy and deals damage
        /// </summary>
        // TODO - Animate the laser slightly (make it pulse)
        protected override void Attack()
        {
            Vector3 triangleCentre = transform.position;

            // Get the end point of the line renderer
            Vector3 direction   = (firePoint.up * range.GetStat());
            Vector3 endPosition = (direction + triangleCentre);


            // Get all enemies the laser hits
            var results = new List <Collider2D>();

            Physics2D.OverlapCapsule(direction / 2 + triangleCentre, new Vector2(range.GetStat(), lineRenderer.endWidth),
                                     CapsuleDirection2D.Vertical, transform.rotation.y, new ContactFilter2D().NoFilter(), results);
            List <Enemy> enemies = results.Select(result => result.transform.GetComponent <Enemy>()).ToList();

            enemies.RemoveAll(x => x == null);

            // Deal damage to every enemy hit
            foreach (Enemy enemy in enemies)
            {
                enemy.TakeDamage(damage.GetStat() * Time.deltaTime, gameObject);
            }
            foreach (Module module in modules)
            {
                module.OnHit(enemies, this);
            }

            // Enable visuals
            if (!lineRenderer.enabled)
            {
                lineRenderer.enabled = true;
                //impactEffect.Play();
            }

            // Set Laser positions
            Vector3 firePointPosition = transform.position;

            lineRenderer.SetPosition(0, firePointPosition);
            lineRenderer.SetPosition(1, endPosition);

            // Set impact effect rotation
            Transform impactEffectTransform = impactEffect.transform;
            var       aimDir = (Vector3)((Vector2)firePointPosition - (Vector2)impactEffectTransform.position).normalized;

            impactEffectTransform.rotation = Quaternion.LookRotation(aimDir);

            // Set impact effect position
            impactEffectTransform.position = endPosition + aimDir * 0.2f;
        }
Beispiel #16
0
 void Update()                                   // Update is called once per frame
 {
     move     = Input.GetAxis("Horizontal");
     jump     = Input.GetButtonDown("Jump");
     onGround = Physics2D.OverlapCapsule((Vector2)transform.position + ground_collision, radius, groundLayer);
     if (onGround && jump)
     {
         rb2d.velocity = new Vector2(move * speed, jumpForce);
     }
     else
     {
         rb2d.velocity = new Vector2(move * speed, rb2d.velocity.y);
     }
 }
Beispiel #17
0
        /// <summary>
        /// 计算闪烁位置
        /// </summary>
        public float calFlashDistance()
        {
            Vector2    flashVec     = RuntimeCharacter.dir82Vec(direction);                                                                        //闪烁方向
            Vector2    dropPos      = collCenter + flashVec * flashDistance;                                                                       //落点
            Vector2    colliderSize = new Vector2(collider.bounds.size.x - 0.02f, collider.bounds.size.y - 0.02f);                                 //微调碰撞盒
            Collider2D collHard     = Physics2D.OverlapCapsule(dropPos,
                                                               colliderSize, CapsuleDirection2D.Horizontal, 0f, (1 << 11) | (1 << 4) | (1 << 15)); //落点碰撞判断

            RaycastHit2D raycastHit2D = Physics2D.Raycast(pos, flashVec, flashDistance, (1 << 11) | (1 << 4) | (1 << 15));

            Collider2D collSoft = Physics2D.OverlapCapsule(dropPos,
                                                           colliderSize, CapsuleDirection2D.Horizontal, 0f, (1 << 8));//落点碰撞判断


            float flashDistStep = 0.05f;
            float flashDistRes  = 0.0f;

            if (raycastHit2D || collSoft)
            {
                //寻找最远落点
                while (flashDistStep <= flashDistance)
                {
                    collHard = Physics2D.OverlapCapsule(collCenter + flashVec * flashDistStep,
                                                        colliderSize, CapsuleDirection2D.Horizontal, 0f, (1 << 11) | (1 << 4) | (1 << 15));


                    collSoft = Physics2D.OverlapCapsule(collCenter + flashVec * flashDistStep,
                                                        colliderSize, CapsuleDirection2D.Horizontal, 0f, (1 << 8));//落点碰撞判断

                    debugLog(collHard?.name);
                    debugLog(collSoft?.name);
                    if (collHard)
                    {
                        break;
                    }
                    if (!collSoft || collSoft.isTrigger)
                    {
                        flashDistRes = flashDistStep;
                    }
                    flashDistStep += 0.05f;
                }
                return(flashDistRes);
            }
            //直接闪烁到最远距离
            else
            {
                return(flashDistance);
            }
        }
Beispiel #18
0
    public bool CheckPenetrate(float reduceOfs, LayerMask mask)
    {
        if (mCapsuleColl)
        {
            Transform collT    = transform;
            Vector2   collPos  = collT.position + collT.localToWorldMatrix.MultiplyPoint3x4(mCapsuleColl.offset);
            Vector2   collSize = mCapsuleColl.size; collSize.y -= reduceOfs;

            return(Physics2D.OverlapCapsule(collPos, collSize, mCapsuleColl.direction, collT.eulerAngles.z, mask) != null);
        }
        else
        {
            return(Physics2D.OverlapCircle(transform.position, mRadius - reduceOfs, mask) != null);
        }
    }
Beispiel #19
0
    private void DropDown()
    {
        Collider2D colliderCheck = Physics2D.OverlapCapsule(coll.bounds.center + Vector3.down * jumpCastOffset, new Vector2(coll.size.x * 0.9f, coll.size.y * 0.9f), CapsuleDirection2D.Vertical, 0f, jumpMask);

        if (!falling && !frozen && colliderCheck && colliderCheck.CompareTag("DropThrough"))
        {
            if (currentState == State.Idle || currentState == State.Walk)
            {
                TriggerFall();
                Physics2D.IgnoreCollision(coll, colliderCheck);
                //Debug.Log ("Collision disabled");
                StartCoroutine(RestoreCollision(colliderCheck));
            }
        }
    }
Beispiel #20
0
    // được gọi bơi Attack animation
    private void Attack()
    {
        if (eData.CurrentHealth <= 0)
        {
            return;
        }
        Collider2D hit = Physics2D.OverlapCapsule(transform.position + AttackOffSet, AttackRange, CapsuleDirection2D.Vertical, 0, playerMask);

        if (hit)
        {
            object[] package = new object[1];
            package[0] = AttackDamage;
            hit.SendMessage("TakeDamage", package);
        }
    }
Beispiel #21
0
        public void UpdateBashCommon()
        {
            // RAMP VELOCITY TO ZERO
            //if (vel.sqrMagnitude > 0.5f) {
            //	vel *= bashSpeedFalloffMult;
            //} else {
            //	vel = Vector2.zero;
            //}

            // FIND TARGET
            var bashTar = Physics2D.OverlapCapsule(super.body.position + bashCollider.offset, bashCollider.size, bashCollider.direction, 0, ~(1 << 8) /*player*/);

            bashTarget = (bashTar && bashTar.tag == "Projectile") ? bashTar.transform : null;

            // COOLDOWN
            if (bashCooldown > 0)
            {
                bashCooldown -= Time.fixedDeltaTime;
            }

            if (bashTarget)
            {
                // MOVE ARROW
                bashArrow.position      = bashTarget.position;
                bashArrow.localRotation = Quaternion.Euler(0, 0, bashAngle);

                // START BASH
                if (InputWrapper.GetBash() && !bashInit && bashCooldown <= 0)
                {
                    bashInit        = true;
                    super.mode      = MoveMode.BASH;
                    bashTimeStarted = Time.unscaledTime;
                }
            }

            var isBash = super.mode == MoveMode.BASH;

            if (!isBash)
            {
                bashInit = false;
            }

            bashArrow.gameObject.SetActive(isBash);

            // SET BULLET TIME
            Time.timeScale      = isBash ? 0.01f : 1;
            Time.fixedDeltaTime = Time.timeScale * super.initFixedDeltaTimescale;
        }
Beispiel #22
0
    void CheckCollision()
    {
        Vector2 capPos  = new Vector2(transform.position.x, transform.position.y) + coll.cap.offset;
        Vector2 capSize = new Vector2(1.1f, 2.1f);

        coll.standing = Physics2D.OverlapCapsule(capPos, coll.cap.size, coll.cap.direction, 0f, coll.groundLayer);

        if (!coll.standing)
        {
            coll.onWall = Physics2D.OverlapCapsule(capPos, capSize, coll.cap.direction, 0f, coll.groundLayer);
        }
        else
        {
            coll.onWall = false;
        }
    }
Beispiel #23
0
    // Update is called once per frame
    void Update()
    {
        pointPlayer = new Vector2(player.transform.position.x, player.transform.position.y);
        sizePlayer  = new Vector2(1.5f, 5.5f);//the size of the capsule collider of the player

        //bool isOverlappingFrontLayer = Physics2D.OverlapCapsule(playerPosition, playerHeight, CapsuleDirection2D.Vertical, playerEulerAngleZ, frontLayerMask) != null;
        bool isOverlappingFrontLayer = Physics2D.OverlapCapsule(pointPlayer, sizePlayer, CapsuleDirection2D.Vertical, 0, frontLayer) != null;

        Debug.Log(isOverlappingFrontLayer);

        /* if (isOverlappingFrontLayer)
         * {
         *   // capsule is overlapping front layer
         *   //Debug.Log("overlaping with frontLayer");
         * }*/
    }
    //------------------------------------------------------------------


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

    void FixedUpdate()
    {
        Vector2 capPos  = new Vector2(transform.position.x, transform.position.y) + cap.offset;
        Vector2 capSize = new Vector2(1f, 2f);

        standing = Physics2D.OverlapCapsule(capPos, cap.size, cap.direction, 0f, groundLayer);

        if (!standing)
        {
            onWall = Physics2D.OverlapCapsule(capPos, capSize, cap.direction, 0f, groundLayer);
        }
        else
        {
            onWall = false;
        }
    }
Beispiel #25
0
        // được gọi bơi Attack animation
        private void Attack()
        {
            if (eData.CurrentHealth <= 0)
            {
                return;
            }
            Collider2D hit = Physics2D.OverlapCapsule(attackPos.transform.position, new Vector2(AttackRange.x * facingDirection, AttackRange.y), CapsuleDirection2D.Horizontal, 0, playerMask);

            if (hit)
            {
                object[] package = new object[2];
                package[0] = AttackDamage;
                package[1] = facingDirection;
                hit.SendMessage("TakeDamage", package);
            }
        }
Beispiel #26
0
    void Update()
    {
        isGrounded = Physics2D.OverlapCircle(feetPos.position, feetCheckRadius, whatIsGround);
        isHitting  = Physics2D.OverlapCapsule(facePos.position, new Vector2(faceCheckX, faceCheckY),
                                              CapsuleDirection2D.Vertical, 0, whatIsGround);
        isWinning = Physics2D.OverlapCapsule(facePos.position, new Vector2(faceCheckX, faceCheckY),
                                             CapsuleDirection2D.Vertical, 0, whatIsWin);

        if ((Input.GetKeyDown(KeyCode.Space) || Input.GetMouseButtonDown(0)) && isGrounded == true)
        {
            isJumping       = true;
            jumpTimeCounter = jumpTime;
            rb.velocity     = Vector2.up * jumpForce;
        }

        if ((Input.GetKey(KeyCode.Space) || Input.GetMouseButton(0)) && isJumping == true)
        {
            if (jumpTimeCounter > 0)
            {
                rb.velocity      = Vector2.up * jumpForce;
                jumpTimeCounter -= Time.deltaTime;
            }
            else
            {
                isJumping = false;
            }
        }

        if (Input.GetKeyUp(KeyCode.Space) || Input.GetMouseButtonUp(0))
        {
            isJumping = false;
        }

        if (isHitting)
        {
            highScoreText.GetComponent <HighScoreCounter>().checkForHighScore(rb);
            FindObjectOfType <AudioManager>().Play("Death" + Random.Range(1, 5).ToString());
            SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
        }
        else if (isWinning)
        {
            winGame.SetActive(true);
            FindObjectOfType <AudioManager>().Play("Win2");
            winPoint.SetActive(false);
        }
    }
Beispiel #27
0
    private void FixedUpdate()
    {
        _rigidbody.velocity = new Vector2(_horizontalInput * _speed, _rigidbody.velocity.y);

        if (_horizontalInput < 0)
        {
            _sprite.flipX = true;
        }
        else if (_horizontalInput > 0)
        {
            _sprite.flipX = false;
        }

        _animator.SetFloat("Speed", _rigidbody.velocity.magnitude);

        _grounded = Physics2D.OverlapCapsule(_collider.bounds.center, _collider.size * 1.1f, direction: CapsuleDirection2D.Vertical, 0, _groundMask) != null;
    }
Beispiel #28
0
    private bool GetValidSpot(out Vector2 validSpot)
    {
        Bounds wbounds = MainScript.instance.worldBounds.bounds;


        for (int i = 0; i < VALIDSPOT_ATTEMPTS_MAX; i++)
        {
            Vector2 spotInMap = new Vector2(Random.Range(-wbounds.extents.x, wbounds.extents.x), Random.Range(-wbounds.extents.y, wbounds.extents.y)) + (Vector2)wbounds.center;

            if (!Physics2D.OverlapCapsule(spotInMap, new Vector2(2, 2), CapsuleDirection2D.Vertical, 0, LayerMask.GetMask("Unit", "Ground")))
            {
                validSpot = spotInMap;
                return(true);
            }
        }
        validSpot = new Vector2();
        return(false);
    }
Beispiel #29
0
    private void FixedUpdate()
    {
        _coolDownTimer -= Time.deltaTime;

        if (_coolDownTimer > 0)
        {
            return;
        }

        var player = Physics2D.OverlapCapsule(transform.position, new Vector2(1.5f, 11f), CapsuleDirection2D.Vertical, 0, PlayerLayer);

        if (player != null)
        {
            Instantiate(ShotPrefab, transform.position, Quaternion.identity).GetComponent <Rigidbody2D>();

            _coolDownTimer = _shootCoolDown;
        }
    }
Beispiel #30
0
    static bool CheckPos(Vector2 pos)
    {
        if (Physics2D.OverlapCapsule(pos, new Vector2(COLX, COLY), CapsuleDirection2D.Horizontal, 0F, mask))
        {
            return(false);
        }
        Vector2 playerPos = GameObject.Find("Player").transform.position;

        if ((pos - playerPos).magnitude < 5F)
        {
            return(false);
        }
        if ((pos - playerPos).magnitude > 13F)
        {
            return(false);
        }
        return(true);
    }