void CastRayAndOrientPlayer(out float angle, out float yCorr)
    {
        //Cast the ray and have the player tile according to the angle of the ground
        RaycastHit2D hit = Physics2D.CircleCast(groundCheck.transform.position, groundCheckCircleRadius, -gameObject.transform.up, 0.5f, whatToDetect);

        //Get the angle with the world right vector
        Vector3 dir = gameObject.transform.up;

        yCorr = 0;
        angle = 0;
        //Debug.Log("collider is: " + hit.collider);

        if (hit.collider != null)
        {
            angle = Vector3.Angle(Vector3.up, hit.normal);

            if (playerState != PlayerStates.jumping)
            {
                if (angle < 65)
                {
                    if (angle > 0.05f)
                    {
                        dir = Vector3.Lerp(gameObject.transform.up, hit.normal, 0.2f);
                    }
                    else
                    {
                        dir = hit.normal;
                    }

                    playerUpOrientation = dir;
                }
            }
        }
        else
        {
            //Debug.Log("Player up orientation set to world");
            dir = Vector3.Lerp(gameObject.transform.up, Vector3.up, 0.15f);
            playerUpOrientation = dir;
        }
        if (playerState == PlayerStates.falling)
        {
            //Debug.Log("Distance to ground is: " + Vector3.Distance(hit.point, gameObject.transform.position));

            yCorr = -(gameObject.transform.position.y - hit.point.y);
        }
    }
    void Update()
    {
        RaycastHit2D hit = Physics2D.CircleCast(transform.position, range, Vector2.zero, 0, targetLayer);

        if (hit)
        {
            Vector2 direction = (hit.collider.transform.position - transform.position).normalized;
            transform.Translate(direction * speed * Time.deltaTime);

            if (direction.x != 0)
            {
                Vector2 scale = transform.localScale;
                scale.x = Mathf.Sign(direction.x);
                transform.localScale = scale;
            }
        }
    }
 public void OnTriggerEnter2D(Collider2D collision)
 {
     if (collision.tag != "Player")
     {
         hit = Physics2D.CircleCast(transform.position, colliderReference.radius, rigidbodyReference.velocity.normalized, 0.1f, whatIsDestructible);
         if (hit)
         {
             DestructibleTileMap damageable = hit.collider.gameObject.GetComponent <DestructibleTileMap>();
             if (!Equals(damageable, null))
             {
                 Vector2 positionInTile = (hit.point - (Vector2)transform.position).normalized;
                 damageable.Damage(this, hit.point + (positionInTile.normalized * 0.5f));
             }
         }
         Destroy(this.gameObject);
     }
 }
Exemple #4
0
    IEnumerator ShootRay()
    {
        //RaycastHit2D hitInfo = Physics2D.Raycast(firePoint.position, firePoint.right, 100f, hitMask.value);
        RaycastHit2D hitInfo;

        if (gameObject.layer == LayerMask.NameToLayer("Player_outside"))
        {
            hitInfo = Physics2D.CircleCast(firePoint.position, 10f, Vector2.zero, 0f, hitMaskOutside.value);
        }
        else
        {
            hitInfo = Physics2D.CircleCast(firePoint.position, 10f, Vector2.zero, 0f, hitMaskInside.value);
        }

        if (hitInfo && (hitInfo.transform.position.x > firePoint.position.x) == character.FacingRight)         //in range and facing the player
        {
            Debug.Log(hitInfo.transform.name);
            Enemy enemy = hitInfo.transform.GetComponent <Enemy>();
            if (enemy != null)
            {
                enemy.TakeDamage(50);
            }

            //Instantiate(impactEffect, hitInfo.point, Quaternion.identity);
            //Debug.Log("hit " + hitInfo.transform.name);

            lineRenderer.SetPosition(0, firePoint.position);
            lineRenderer.SetPosition(1, hitInfo.point);

            if (audioSource && hitAudio)
            {
                audioSource.PlayOneShot(hitAudio);
            }
        }
        else
        {
            lineRenderer.SetPosition(0, firePoint.position);
            lineRenderer.SetPosition(1, firePoint.position + firePoint.right * 100);
        }

        lineRenderer.enabled = true;

        yield return(0);

        lineRenderer.enabled = false;
    }
    void GroundCheck()
    {
        //isGrounded = true;

        RaycastHit2D hit = Physics2D.CircleCast(transform.position, 0.1f, Vector2.down, 0.5f, groundLayers); // send a circle down to check for ground

        if (hit && colli.IsTouchingLayers(groundLayers))
        {
            isGrounded           = true;
            colli.sharedMaterial = physMat_ground; // keeps you from sliding on the floor
        }
        else
        {
            isGrounded           = false;
            colli.sharedMaterial = physMat_air; // keeps you from sticking to walls
        }
    }
Exemple #6
0
    public float maxMovementSpeed = 5f;  // Defines the maximum speed this character can move.

    /// <summary>
    /// Moves the character in the vector direction. Collides with walls / colliders if it can't move in that direction.
    /// Call this in FixedUpdate, not update because this uses physics.
    /// </summary>
    public void Move(Vector2 targetMoveVector)
    {
        // Get move vector for this frame.
        Vector2 translationVectorThisFrame = Vector2.ClampMagnitude(targetMoveVector, maxMovementSpeed);

        // Collision check for going through walls.
        RaycastHit2D hit = Physics2D.CircleCast(transform.position, characterRadius, translationVectorThisFrame, translationVectorThisFrame.magnitude);

        if (hit.transform != null)
        {
            // Bump math! Bump bump bump!
            translationVectorThisFrame = translationVectorThisFrame + hit.normal * translationVectorThisFrame.magnitude;
        }

        // Skkrrt! This moves the object based on the displacement vector we calculated.
        transform.Translate(translationVectorThisFrame);
    }
    public void Attack()
    {
        if (isDead)
        {
            return;
        }


        aud.PlayOneShot(soundAttack, 0.02f);

        RaycastHit2D hit = Physics2D.CircleCast(transform.position, rangeAttack, -transform.up, 0, 1 << 8);

        if (hit.collider.tag == "敵人")
        {
            hit.collider.GetComponent <Enemy>().Hit(attack);
        }
    }
Exemple #8
0
    IEnumerator SpawnTimer()
    {
        isSpawning = true;

        RaycastHit2D hit            = Physics2D.CircleCast(transform.position, 0.25f, Vector2.down, Mathf.Infinity); //下向きにレイを飛ばす
        float        spawnPositionY = hit.point.y;                                                                   //レイが当たったY座標を取得

        spawnPositionY += Random.Range(minPositionOffsetY, maxPositionOffsetY);                                      //高さをランダムにずらす

        Instantiate(coinPrefab, new Vector2(transform.position.x, spawnPositionY + 0.5f), Quaternion.identity);

        float waitTime = Random.Range(minWaitTime, maxWaitTime);

        yield return(new WaitForSeconds(waitTime));

        isSpawning = false;
    }
Exemple #9
0
    Vector2 ObstacleRays()
    {
        Vector2[] rayDirections = BoidHelper.directions;

        for (int i = 0; i < rayDirections.Length; i++)
        {
            Vector2 dir = cachedTransform.TransformDirection(rayDirections[i]);
            Ray     ray = new Ray(position, dir);
            //Debug.DrawRay(position, dir, Color.yellow);
            if (!Physics2D.CircleCast(ray.origin, Settings.castRadius, ray.direction, Settings.obstacleMask))
            {
                return(dir);
            }
        }

        return(up);
    }
Exemple #10
0
    private void Update()
    {
        if (!_active)
        {
            return;
        }

        RaycastHit2D hit = Physics2D.CircleCast(_ball.transform.position, _ballRadius, _ballVelocity.normalized, _ballVelocity.magnitude * Time.deltaTime, _ballCollisionLayers);

        if (hit.collider != null)
        {
            if (_paddles.Contains(hit.collider.gameObject))
            {
                _ballVelocity = Quaternion.Euler(0.0f, 0.0f, Random.Range(_maxRandomAngle, _maxRandomAngle)) * _ballVelocity;
            }

            PlayerValues player = hit.collider.GetComponent <PlayerValues>();
            if (player != null)
            {
                player.Die();
                ResetPong();
            }
            else
            {
                _ballVelocity = Vector2.Reflect(_ballVelocity, hit.normal);
                AudioManager.PlaySound("Hit");
            }
        }

        if (_ball != null)
        {
            _ball.transform.position += (Vector3)_ballVelocity * Time.deltaTime;
        }

        foreach (GameObject paddle in _paddles)
        {
            Vector3 position = paddle.transform.position;
            position.y = _ball.transform.position.y;
            paddle.transform.position = position;
        }

        if (Time.time - _startTime > _duration)
        {
            ResetPong();
        }
    }
Exemple #11
0
    public bool CheckCast(float reduceOfs, Vector2 dir, out RaycastHit2D hit, float dist, int mask)
    {
        if (mCapsuleColl)
        {
            Transform collT    = transform;
            Vector2   collPos  = collT.position + collT.localToWorldMatrix.MultiplyPoint3x4(mCapsuleColl.offset);
            Vector2   collSize = mCapsuleColl.size; collSize.y -= reduceOfs;

            hit = Physics2D.CapsuleCast(collPos, collSize, mCapsuleColl.direction, collT.eulerAngles.z, dir, dist, mask);
            return(hit.collider != null);
        }
        else
        {
            hit = Physics2D.CircleCast(transform.position, mRadius - reduceOfs, dir, dist, mask);
            return(hit.collider != null);
        }
    }
Exemple #12
0
    private void Update()
    {
        if (Launched)
        {
            time += Time.deltaTime;
            if (time > 5f)
            {
                Destroy(this.gameObject);
            }
        }
        RaycastHit2D circle = Physics2D.CircleCast(transform.position, radius, Vector2.up, radius, layermask);

        if (circle)
        {
            this.GetComponent <AIDestinationSetter>().target = circle.transform;
        }
    }
Exemple #13
0
        public bool Cast(Vector2 origin)
        {
            RaycastHit2D hit =
                Physics2D.CircleCast(origin, Radius, Vector2.down, RayLength, Mask);


            if (hit.collider != null)
            {
                GameObject detectedObject = hit.collider.gameObject;
                LastDetectedObject  = detectedObject;
                ObjectBeingDetected = detectedObject;
                return(true);
            }

            ObjectBeingDetected = null;
            return(false);
        }
Exemple #14
0
    public void DrawRay()
    {
        hit = Physics2D.CircleCast(transform.position, 0.161f, transform.right);
        line.SetPosition(0, transform.position);
        line.SetPosition(1, hit.point);
        Vector3 rayReflect = Vector3.Reflect((Vector3)hit.centroid - line.GetPosition(0), hit.normal);

        hit = Physics2D.Raycast(hit.centroid, rayReflect.normalized, 4f);
        if ((Vector3)hit.point == Vector3.zero)
        {
            line.SetPosition(2, line.GetPosition(1) + rayReflect.normalized * 4f);
        }
        else
        {
            line.SetPosition(2, line.GetPosition(1) + rayReflect.normalized * hit.distance);
        }
    }
    void hoverDetect()
    {
        Vector3 mousePos   = Camera.main.ScreenToWorldPoint(Input.mousePosition);
        Vector2 mousePos2D = new Vector2(mousePos.x, mousePos.y);

        hit = Physics2D.CircleCast(mousePos2D, cursorRadius, Vector2.zero);
        if (hit)
        {
            hoverObject = hit.collider.gameObject;
            displayAttractTrack();
        }
        else
        {
            hoverObject = null;
            cancelAttractTrack();
        }
    }
Exemple #16
0
    // Update is called once per frame
    void FixedUpdate()
    {
        var cast = Physics2D.CircleCast(transform.position, leverRange, Vector2.one, 0, 1 << 10);

        if (cast.collider)
        {
            if (!isOnLever)
            {
                cast.collider.gameObject.GetComponent <Lever>().OnFlip();
            }
            isOnLever = true;
        }
        else
        {
            isOnLever = false;
        }
    }
Exemple #17
0
    /// <summary>
    /// Gets the first object in the direction of wherever the user tapped.
    /// </summary>
    /// <returns>Returns the raycast collision itself so that the position of contact can be preserved. Returns an empty `RaycastHit2D` if the object hit does not contain a `<see cref="StickInteractable" />`. You can evaluate a `RaycastHit2D` as a boolean to determine if this function succeeded or failed.</returns>
    RaycastHit2D GetFirstObjHitByStick(Touch finger)
    {
        Vector2      tapLocation = TouchHelper.GetTouchWorldPosition(finger);
        float        radius      = finger.radius + expandTouchRadiusBy;
        Vector2      direction   = tapLocation - (Vector2)transform.position;
        RaycastHit2D hit         = Physics2D.CircleCast(tapLocation, radius, direction.normalized, Mathf.Max(maxTapDistance, direction.magnitude));

        // just play the hits 💿 ayy lmao
        if (hit && hit.collider.GetComponent <StickInteractable>() != null)
        {
            return(hit);
        }
        else
        {
            return(new RaycastHit2D());
        }
    }
    IEnumerator SendPunch()
    {
        anim.SetTrigger("punch");
        yield return(new WaitForSeconds(0.9f));

        Vector2 punchPosition = sr.flipX ? punchPositionRight.position : punchPositionLeft.position;

        var punch = Physics2D.CircleCast(punchPosition, radiusPunch, Vector2.up);

        if (punch.collider != null)
        {
            if (punch.collider.gameObject != gameObject)
            {
                punch.collider.SendMessage("Punch", transform.position, SendMessageOptions.DontRequireReceiver);
            }
        }
    }
Exemple #19
0
    internal override void calculateDesiredDirection()
    {
        // wander
        Vector2 seek = wander;

        // seeking food subsume wander
        if (foodTarget)
        {
            seek = foodTarget.position - transform.position;
        }

        // flee or attack other boar subsume other steering
        if (boarTarget)
        {
            seek = boarTarget.position - transform.position;

            if (state == BoarState.Flee)
            {
                // flee
                seek = -seek;
            }
        }

        desired = seek.normalized;

        // Obstacle avoidance
        RaycastHit2D hit = Physics2D.CircleCast(transform.position, GetComponent <CircleCollider2D>().radius, rb2D.velocity, visionRadius, 0x100);

        if (hit.collider != null)
        {
            Vector2 avoid = transform.position - hit.collider.transform.position;

            // weight avoid vector by distance
            float weight = (visionRadius - avoid.magnitude) * 1.5f;

            avoid = avoid.normalized * weight;

            // Inhibit wander
            wander = avoid;

            desired += avoid;
        }

        // rotate vector for random wander
        desired = Vector3.RotateTowards(desired, -desired, Random.Range(-0.2f, 0.2f), 0f);
    }
Exemple #20
0
    private bool Attack(Vector2 direction, float attackPower, float distance, float knockback)
    {
        float x = direction.x;
        float y = direction.y;

        if (Mathf.Abs(x) > Mathf.Abs(y))
        {
            direction.x = Mathf.Sign(x);
            direction.y = 0;
        }
        else
        {
            direction.y = Mathf.Sign(y);
            direction.x = 0;
        }

        Vector2      position = this.gameObject.transform.position;
        RaycastHit2D hit      = Physics2D.CircleCast(position, 1, direction, distance, mask);

        Debug.DrawRay(position, direction, Color.blue, 1);
        CharacterHealthComponent health = null;
        Rigidbody2D body = null;

        try
        {
            health = hit.collider.gameObject.GetComponent <CharacterHealthComponent>();
        }
        catch
        {
            //add debug code here if needed
        }

        if (hit && health != null)
        {
            health.Damage(Mathf.CeilToInt(attackPower));
            body = health.gameObject.GetComponent <Rigidbody2D>();
            if (body != null && knockback > 0)
            {
                body.AddForce(direction * knockback, ForceMode2D.Impulse);
            }
            return(true);
        }

        return(false);
    }
Exemple #21
0
    // Update is called once per frame
    void Update()
    {
        if (inGame)
        {
            if (transform.position.x > 36 || transform.position.x < -36)
            {
                Destroy(gameObject);
            }
            else if (transform.position.y > 20.3 || transform.position.y < -20.3)
            {
                Destroy(gameObject);
            }
        }

        if (lifeTime <= 0)
        {
            Destroy(gameObject);
        }
        else
        {
            lifeTime -= Time.deltaTime;
        }

        RaycastHit2D hitInfo = Physics2D.CircleCast(transform.position, raycastRadius, transform.up, raycastDistance, whatIsSolid); // raycasts circle of raycastRadius that collects collision information

        if (hitInfo.collider != null)                                                                                               // if there was collision
        {
            if (hitInfo.collider.CompareTag("EnemyRectangle"))                                                                      // and with an object tagged "Enemy"
            {
                hitInfo.collider.GetComponent <EnemyRectangleController>().TakeDamage(damage);                                      // get that object script and use TakeDamage function (make damage to the enemy)
            }
            else if (hitInfo.collider.CompareTag("EnemyWave"))
            {
                hitInfo.collider.GetComponent <EnemyWaveController>().TakeDamage(damage);    // get that object script and use TakeDamage function (make damage to the enemy)
            }
            else if (hitInfo.collider.CompareTag("EnemyCircle"))
            {
                hitInfo.collider.GetComponent <EnemyCircleController>().TakeDamage(damage);    // get that object script and use TakeDamage function (make damage to the enemy)
            }
            GameObject.FindGameObjectWithTag("SoundManager").GetComponent <AudioManager>().playSound("shotHit");
            Destroy(gameObject);    // destroy projectile function
        }

        transform.Translate(Vector2.up * bulletVelocity * Time.deltaTime);  // move bullet
    }
    void Update()
    {
        if (foundMonsters.Count == 0)
        {
            tracking = false;
            anim.SetBool("OnTracking", false);
            onPatrol = true;
        }
        else
        {
            Finding(foundMonsters);
        }

        if (queueSign != CheckQueueSign())
        {
            moveCount++;
            queueSign++;
        }

        if (moveCount == 2)
        {
            monsterHit = Physics2D.CircleCast(transform.position, 0.7f, Vector2.zero, 0f, mask);
            if (monsterHit)
            {
                readyToAttack = true;
                enemyDir      = monsterHit.transform.position;
            }

            if (!readyToAttack && !onPatrol)
            {
                moveCount = 0;
                Tracking();
            }
            else if (!readyToAttack && onPatrol)
            {
                moveCount = 0;
                Patrolling();
            }
            else
            {
                moveCount = 0;
                AttackReady(enemyDir);
            }
        }
    }
Exemple #23
0
        //----------------------------------------------
        //	接地判定時のコールバック
        //----------------------------------------------

        /// <summary>
        /// 何かに設置したときに実行される
        /// </summary>
        protected virtual void OnGroundEnter()
        {
            m_rigidbody.constraints = RigidbodyConstraints2D.FreezeRotation | RigidbodyConstraints2D.FreezePositionX;

            //滑り止め
            m_rigidbody.velocity = new Vector2(0, m_rigidbody.velocity.y);

            #region 敵キャラが近くにいたらこちらを振り向かせる
            RaycastHit2D enemyInfo = Physics2D.CircleCast(
                m_searchArea.transform.position, m_searchArea.radius,
                Vector2.zero, 0, 1 << LayerMask.NameToLayer("SearchArea"));

            if (enemyInfo)
            {
                SearchArea searchArea = enemyInfo.transform.GetComponent <SearchArea>();
                if (searchArea)
                {
                    searchArea.OnEncountItem(this);
                }
            }
            m_searchArea.enabled = false;
            #endregion

            #region アイテムの上に置かれたら積み重ねる
            //接地した情報からItemを抽出する
            RaycastHit2D hitInfo = Physics2D.BoxCast(
                m_foot.transform.position, m_foot.bounds.size,
                0, Vector2.zero, 0, 1 << LayerMask.NameToLayer("Item") | 1 << LayerMask.NameToLayer("Ground"));

            if (!hitInfo)
            {
                return;
            }

            if (hitInfo.transform.gameObject.layer == LayerMask.NameToLayer("Item"))
            {
                Item item = hitInfo.transform.GetComponent <Item>();
                if (item)
                {
                    this.m_itemParent = item;
                    item.RegisterChild(this);
                }
            }
            #endregion
        }
Exemple #24
0
    IEnumerator dashTransition(Vector2 direction)
    {
        float currentTime = 0.0f;

        canDash = false;
        charAnimator.SetBool("IsDash", true);
        dashParticles.Play();
        dashParticles.transform.localScale = transform.localScale;
        Vector2 oldPosition = transform.position;

        while (currentTime < 0.2f)
        {
            ownCollider.enabled = false;
            bigCollider.enabled = false;
            RaycastHit2D[] hits = new RaycastHit2D[100];

            ContactFilter2D filter = new ContactFilter2D();
            filter.useTriggers = false;


            int   count          = Physics2D.CircleCast(transform.position + (Vector3)hitOffset, hitRadius, direction, filter, hits, hitRadius + dashPower * Time.deltaTime);
            float distanceDashed = Vector2.Distance(oldPosition, transform.position);
            ownCollider.enabled = true;
            bigCollider.enabled = true;
            Debug.Log("hit something!");
            //Debug.Log(distanceDashed);
            if (count > 0)
            {
                for (int i = 0; i < 100; i++)
                {
                    heroScript other = hits[0].collider.transform.parent.GetComponentInParent <heroScript>();
                    if (other != null)
                    {
                        other.StartCoroutine(other.wasBumped(stunDuration, direction * distanceDashed));
                    }
                }
                StartCoroutine(DashCooldown());
                yield break; //returns
            }
            rb.AddForce(direction * dashPower, ForceMode2D.Impulse);
            currentTime += Time.deltaTime;
            yield return(new WaitForEndOfFrame());
        }
        StartCoroutine(DashCooldown());
    }
Exemple #25
0
    private void shoot()
    {
        int          hitLayers = LayerMask.GetMask("Ball");
        RaycastHit2D hit       = Physics2D.CircleCast(transform.position, 0.5f, transform.right, shotDistance, hitLayers);

        if (GetComponentInChildren <Animator>() != null)
        {
            GetComponentInChildren <Animator> ().SetTrigger("hShoot");
        }
        else
        {
            Debug.Log("Testicles");
        }
        if (hit.collider != null)
        {
            if (hit.transform.gameObject.tag == "Ball" || hit.transform.gameObject.tag == "PowerUp")
            {
                if (hit.transform.gameObject.tag == "Ball" &&
                    hit.transform.gameObject.GetComponent <Rigidbody2D>().gravityScale == 0.0f)
                {
                    hit.transform.gameObject.GetComponent <Rigidbody2D>().gravityScale = 0.5f;
                }

                Debug.Log(hit.transform.gameObject.GetComponent <Rigidbody2D>().isKinematic);

                Vector2 oppositeNormal       = hit.normal * -1;
                float   ballCannonDotProduct = Vector3.Dot(transform.right, hit.collider.gameObject.GetComponent <Rigidbody2D>().velocity);
                float   scaledShotStrength   = (ballCannonDotProduct >= 0) ? shotStrength : shotStrength * (1 + Mathf.Abs(ballCannonDotProduct));
                Debug.Log((1 + Mathf.Abs(ballCannonDotProduct)));
                Debug.Log((new Vector2(transform.right.x, transform.right.y) + oppositeNormal).normalized * scaledShotStrength);
                hit.transform.gameObject.GetComponent <Rigidbody2D>().AddForce((new Vector2(transform.right.x, transform.right.y) + oppositeNormal).normalized * scaledShotStrength, ForceMode2D.Impulse);
            }
        }
        if (catPaw != null)
        {
            catPaw.SetTrigger("push");
        }

        GameObject soundEngine = GameObject.FindGameObjectWithTag("SoundEngine");

        if (soundEngine != null)
        {
            soundEngine.GetComponent <SoundEngine>().playHorn();
        }
    }
Exemple #26
0
        Vector2 getMovementVector(float val)
        {
            Vector2 dir = new Vector2(0, 0);

            if (Input.GetKey("s"))
            {
                dir += new Vector2(0, -1);
            }
            if (Input.GetKey("w"))
            {
                dir += new Vector2(0, 1);
            }
            if (Input.GetKey("a"))
            {
                dir += new Vector2(-1, 0);
            }
            if (Input.GetKey("d"))
            {
                dir += new Vector2(1, 0);
            }

            if (Physics2D.CircleCast(
                    transform.position,
                    GetComponent <CircleCollider2D>().radius,
                    new Vector3(dir.x, 0, 0),
                    val,
                    LayerMask.GetMask("Wall")
                    ).collider != null)
            {
                dir.x = 0;
            }
            if (Physics2D.CircleCast(
                    transform.position,
                    GetComponent <CircleCollider2D>().radius,
                    new Vector3(0, dir.y, 0),
                    val,
                    LayerMask.GetMask("Wall")
                    ).collider != null)
            {
                dir.y = 0;
            }

            dir.Normalize();
            return(dir * val);
        }
Exemple #27
0
        private void BeginDrag(float screenX, float screenY)
        {
            Vector3 pos = new Vector3(screenX, screenY, 0.0f);

            pos = Camera.main.ScreenToWorldPoint(pos);
            RaycastHit2D hit = Physics2D.CircleCast(pos, 10.0f, Vector2.zero);

            if (hit.transform != null && hit.transform.gameObject.name == "Asteroid")
            {
                draggingAsteroid = hit.transform.gameObject;
                draggingAsteroid.GetComponent <Rigidbody2D>().velocity        = Vector2.zero;
                draggingAsteroid.GetComponent <Rigidbody2D>().angularVelocity = 0.0f;
            }
            else
            {
                longPressGesture.Reset();
            }
        }
Exemple #28
0
    void OnTriggerStay2D(Collider2D other)
    {
        if (other.gameObject.tag == "Player")
        {
            RaycastHit2D hit = Physics2D.CircleCast(transform.position, 1.5f, other.transform.position, 9f);

            if (hit.collider.tag == "Player")
            {
                Debug.Log("I FOUND YOU!");
                enemy.target = player;
                enemy.active = true;
            }
            else
            {
                Debug.Log("Lost 'em...");
            }
        }
    }
    public void AgroPlayer()
    {
        RaycastHit2D playerCheck;
        Vector3      p1 = transform.position;

        playerCheck = Physics2D.CircleCast(transform.position, castRadius, Vector2.zero, 0.3f, playerLayer);

        if (playerCheck.transform != null)
        {
            seePlayer = true;
            //distanceToPlayer = hit.distance;
        }

        else
        {
            seePlayer = false;
        }
    }
    public void Collect()
    {
        RaycastHit2D hit = Physics2D.CircleCast(transform.position, collectAbleRadius, Vector2.up, 0.2f, collectableLayer);

        if (hit.collider != null)
        {
            CollectAble col = hit.collider.gameObject.GetComponent <CollectAble>();

            // TODO add responce for to much loot.
            if (col == null || currentWeight + col.data.weight > maxWeight)
            {
                return;
            }

            Collect(col);
            Destroy(col.gameObject);
        }
    }