private void LookAhead() { isGroundAhead = Physics2D.Linecast(transform.position, LookAheadPoint.position, CollisionLayer); Debug.DrawLine(transform.position, LookAheadPoint.position, Color.green); }
// Update is called once per frame void Update() { // jump bool jump = Input.GetButtonDown(jumpInput); if (jump) { Vector2 groundPos = (Vector2)(transform.position - groundVector); // Use Linecast to see if there is ground under the player if (Physics2D.Linecast(transform.position, groundPos, 1 << LayerMask.NameToLayer(groundLayer))) { rigidbody2D.AddForce(new Vector2(0, jumpForce)); } } // horizontal move float x; if (softenInput) { x = Input.GetAxis(horizontalInput); } else { x = stTools.GetAxisNorm(horizontalInput); } if (x > 0 && Physics2D.Linecast(transform.position, transform.position - rightVector, 1 << LayerMask.NameToLayer(groundLayer))) { x = 0; print("!"); } if (x < 0 && Physics2D.Linecast(transform.position, transform.position + rightVector, 1 << LayerMask.NameToLayer(groundLayer))) { x = 0; print("!2"); } Vector2 v = new Vector2(x * speed, rigidbody2D.velocity.y); rigidbody2D.velocity = v; rigidbody2D.angularVelocity = 0; //facing if (v.x < 0) { if (facingRight) { facingRight = false; Vector3 s = gameObject.transform.localScale; s.x *= -1; transform.localScale = s; } } else if (v.x > 0) { if (!facingRight) { facingRight = true; Vector3 s = gameObject.transform.localScale; s.x *= -1; transform.localScale = s; } } }
private void Raycast(PointerEventData eventData, List <RaycastResult> resultAppendList, Ray ray, bool checkForBlocking) { //This function is closely based on //void GraphicRaycaster.Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList) //WriteToLog("Got to start of raycast, canvas=" + canvas); if (canvas == null) { return; } float hitDistance = float.MaxValue; //WriteToLog("checkForBlocking=" + checkForBlocking + "blockingObjects=" + blockingObjects); if (checkForBlocking && blockingObjects != BlockingObjects.None) { float dist = eventCamera.farClipPlane; if (blockingObjects == BlockingObjects.ThreeD || blockingObjects == BlockingObjects.All) { var hits = Physics.RaycastAll(ray, dist, m_BlockingMask); if (hits.Length > 0 && hits[0].distance < hitDistance) { hitDistance = hits[0].distance; } } if (blockingObjects == BlockingObjects.TwoD || blockingObjects == BlockingObjects.All) { var hits = Physics2D.GetRayIntersectionAll(ray, dist, m_BlockingMask); if (hits.Length > 0 && hits[0].fraction * dist < hitDistance) { hitDistance = hits[0].fraction * dist; } } } m_RaycastResults.Clear(); GraphicRaycast(canvas, ray, m_RaycastResults); //WriteToLog("canvas=" + canvas+ " m_RaycastResults.Count="+m_RaycastResults.Count); for (var index = 0; index < m_RaycastResults.Count; index++) { var go = m_RaycastResults[index].graphic.gameObject; bool appendGraphic = true; if (ignoreReversedGraphics) { // If we have a camera compare the direction against the cameras forward. var cameraFoward = ray.direction; var dir = go.transform.rotation * Vector3.forward; appendGraphic = Vector3.Dot(cameraFoward, dir) > 0; } // Ignore points behind us (can happen with a canvas pointer) if (eventCamera.transform.InverseTransformPoint(m_RaycastResults[index].worldPos).z <= 0) { appendGraphic = false; } if (appendGraphic) { float distance = Vector3.Distance(ray.origin, m_RaycastResults[index].worldPos); if (distance >= hitDistance) { continue; } var castResult = new RaycastResult { gameObject = go, module = this, distance = distance, index = resultAppendList.Count, depth = m_RaycastResults[index].graphic.depth, worldPosition = m_RaycastResults[index].worldPos }; resultAppendList.Add(castResult); } } }
public void CollisionMove() { float deltaX = currentSpeed.x; float deltaY = currentSpeed.y; Vector2 p = transform.position; // Check y directions int yDir = (int)Mathf.Sign(deltaY); for (int i = 0; i < divisionsX; i++) { float x = (p.x + center.x - size.x / 2) + i * size.x / (divisionsX - 1); float y = p.y + center.y + yDir * size.y / 2; Ray2D ray = new Ray2D(new Vector2(x, y), new Vector2(0, yDir)); Debug.DrawRay(ray.origin, ray.direction); RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction, Mathf.Abs(deltaY) + skin, collisionMask); if (hit.collider) { float d = Vector2.Distance(ray.origin, hit.point); if (yDir < 0) { grounded = true; currentSpeed.y = 0; } if (d > skin) { deltaY = yDir * (d - skin); } else { deltaY = 0; } break; } } // Check x directions int xDir = (int)Mathf.Sign(deltaX); for (int i = 0; i < divisionsY; i++) { float x = p.x + center.x + xDir * size.x / 2; float y = (p.y + center.y - size.y / 2) + i * size.y / (divisionsY - 1); Ray2D ray = new Ray2D(new Vector2(x, y), new Vector2(xDir, 0)); Debug.DrawRay(ray.origin, ray.direction); RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction, Mathf.Abs(deltaX) + skin, collisionMask); if (hit.collider) { float d = Vector2.Distance(ray.origin, hit.point); wallCollision = true; currentSpeed.x = 0; if (d > skin) { deltaX = xDir * (d - skin); } else { deltaX = 0; } break; } } // Check player velocity angle if (!grounded && !wallCollision) { Vector2 playerDir = new Vector2(deltaX, deltaY).normalized; Vector2 o = new Vector2(p.x + center.x + Mathf.Sign(deltaX) * size.x / 2, p.y + center.y + Mathf.Sign(deltaY) * size.y / 2); Ray2D ray = new Ray2D(o, playerDir); Debug.DrawRay(ray.origin, ray.direction); RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction, Mathf.Sqrt(deltaX * deltaX + deltaY * deltaY), collisionMask); if (hit.collider) { grounded = true; deltaY = 0; } } transform.Translate(new Vector2(deltaX, deltaY)); }
private void VerticalCollisions(ref Vector2 moveAmount) { float directionY = Mathf.Sign(moveAmount.y); float rayLength = Mathf.Abs(moveAmount.y) + skinWidth; for (int i = 0; i < verticalRayCount; i++) { Vector2 rayOrigin = (directionY == -1) ? raycastOrigins.bottomLeft : raycastOrigins.topLeft; rayOrigin += Vector2.right * (verticalRaySpacing * i + moveAmount.x); RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up * directionY, rayLength, collisionMask); Debug.DrawRay(rayOrigin, Vector2.up * directionY, Color.red); if (hit) { if (hit.collider.tag == "Through") { if (directionY == 1 || hit.distance == 0) { continue; } if (collisions.fallingThroughPlatform) { continue; } if (playerInput.y == -1) { collisions.fallingThroughPlatform = true; Invoke("ResetFallingThroughPlatform", fallingThroughPlatformResetTimer); continue; } } moveAmount.y = (hit.distance - skinWidth) * directionY; rayLength = hit.distance; if (collisions.climbingSlope) { moveAmount.x = moveAmount.y / Mathf.Tan(collisions.slopeAngle * Mathf.Deg2Rad) * Mathf.Sign(moveAmount.x); } collisions.below = directionY == -1; collisions.above = directionY == 1; } } if (collisions.climbingSlope) { float directionX = Mathf.Sign(moveAmount.x); rayLength = Mathf.Abs(moveAmount.x) + skinWidth; Vector2 rayOrigin = ((directionX == -1) ? raycastOrigins.bottomLeft : raycastOrigins.bottomRight) + Vector2.up * moveAmount.y; RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, collisionMask); if (hit) { float slopeAngle = Vector2.Angle(hit.normal, Vector2.up); if (slopeAngle != collisions.slopeAngle) { moveAmount.x = (hit.distance * skinWidth) * directionX; collisions.slopeAngle = slopeAngle; } } } }
void OnCollisionEnter2D(Collision2D collision) { int damagePlayer = 0; // Ignore collision when player is invincible Physics2D.IgnoreCollision(collision.gameObject.GetComponent <Collider2D>(), GetComponent <Collider2D>(), isInvincible); if (!isInvincible) { // Collision with enemy EnemyScript enemy = collision.gameObject.GetComponent <EnemyScript>(); if (enemy != null && collision.gameObject.GetComponent <BossScript>() == null) { // Kill the enemy HealthScript enemyHealth = enemy.GetComponent <HealthScript>(); if (enemyHealth != null) { damagePlayer = enemyHealth.hp / 3; if (shieldLevel + 1 >= damagePlayer) { enemyHealth.Damage(enemyHealth.hp); // kill enemy } } if (damagePlayer < 1) { damagePlayer = 1; } } } // Is this a bonus? CollectableScript collectable = collision.gameObject.GetComponentInChildren <CollectableScript>(); if (collectable != null) { // Is this a shield bonus? ShieldScript shield = collision.gameObject.GetComponent <ShieldScript>(); if (shield != null) { shieldLevel = shield.shieldLevel; lastShieldLevel = shieldLevel; updateShieldUi(); updateLifeUi(false); SoundEffectsHelper.Instance.MakeShieldSound(true); Destroy(shield.gameObject); // Remember to always target the game object, otherwise you will just remove the script } else { SoundEffectsHelper.Instance.MakePickupSound(); } // Is this a weapon bonus? changeWeapon(collision.gameObject); // Is this a bomb bonus? BombScript bomb = collision.gameObject.GetComponent <BombScript>(); if (bomb != null) { if (nbBombs < MAX_BOMB) { nbBombs++; GameHelper.Instance.pickupBomb(); } SoundEffectsHelper.Instance.MakePickupSound(); } GameHelper.Instance.collectBonus(collectable.getId()); Destroy(collision.gameObject); // Remember to always target the game object, otherwise you will just remove the script } // Damage the player if necessery if (this.takeDamage(damagePlayer)) { GetComponent <HealthScript>().Damage(1); } }
// Update is called once per frame void Update() { // Inisiasi status pantulan lintasan, yang hanya akan ditampilkan jika lintasan bertumbukan dengan objek tertentu. bool drawBallAtCollision = false; // Titik tumbukan yang digeser, untuk menggambar ballAtCollision Vector2 offsetHitPoint = new Vector2(); // Tentukan titik tumbukan dengan deteksi pergerakan lingkaran RaycastHit2D[] circleCastHit2DArray = Physics2D.CircleCastAll(ballRigidbody.position, ballCollider.radius, ballRigidbody.velocity.normalized); // Untuk setiap titik tumbukan, ... foreach (RaycastHit2D circleCastHit2D in circleCastHit2DArray) { // Jika terjadi tumbukan, dan tumbukan tersebut tidak dengan bola // (karena garis lintasan digambar dari titik tengah bola)... if (circleCastHit2D.collider != null && circleCastHit2D.collider.GetComponent <BallControl>() == null) { // Garis lintasan akan digambar dari titik tengah bola saat ini ke titik tengah bola pada saat tumbukan, // yaitu sebuah titik yang di-offset dari titik tumbukan berdasar vektor normal titik // tersebut sebesar // jari-jari bola. // Tentukan titik tumbukan Vector2 hitPoint = circleCastHit2D.point; // Tentukan normal di titik tumbukan Vector2 hitNormal = circleCastHit2D.normal; // Tentukan offsetHitPoint, yaitu titik tengah bola pada saat bertumbukan offsetHitPoint = hitPoint + hitNormal * ballCollider.radius; // Gambar garis lintasan dari titik tengah bola saat ini ke titik tengah bola pada saat bertumbukan DottedLine.DottedLine.Instance.DrawDottedLine(ball.transform.position, offsetHitPoint); // Kalau bukan sidewall, gambar pantulannya if (circleCastHit2D.collider.GetComponent <SideWall>() == null) { // Hitung vektor datang Vector2 inVector = (offsetHitPoint - ball.TrajectoryOrigin).normalized; // Hitung vektor keluar Vector2 outVector = Vector2.Reflect(inVector, hitNormal); // Hitung dot product dari outVector dan hitNormal. Digunakan supaya garis lintasan ketika // terjadi tumbukan tidak digambar. float outDot = Vector2.Dot(outVector, hitNormal); if (outDot > -1.0f && outDot < 1.0) { // Gambar lintasan pantulannya DottedLine.DottedLine.Instance.DrawDottedLine( offsetHitPoint, offsetHitPoint + outVector * 10.0f); // Untuk menggambar bola "bayangan" di prediksi titik tumbukan drawBallAtCollision = true; } } // Hanya gambar lintasan untuk satu titik tumbukan, jadi keluar dari loop break; } } // Jika true, ... if (drawBallAtCollision) { // Gambar bola "bayangan" di prediksi titik tumbukan ballAtCollision.transform.position = offsetHitPoint; ballAtCollision.SetActive(true); } else { // Sembunyikan bola "bayangan" ballAtCollision.SetActive(false); } }
void FixedUpdate() { bool isSnowClick = heroTransform.isSnowTransform; if (isSnow) lastPosition = transform.position; if (isSnowClick && GameManager.Instance.isCameraFix) { heroTransform.isSnowTransform = false; isSnowClick = false; isSnow = !isSnow; if (!isSnow) { Debug.Log ("Snow Disappear!!!!"); //cloudObject.SetActive (false); //Destroy(cloudObject); GameManager.Instance.Status = "PlayerCloud"; transform.position = new Vector3(cloudController.lastPosition.x, outOfScreenY, 0); } else { Debug.Log ("Snow re-appear!!!!"); //GameObject cloudObject = GameObject.Find ("CloudBall"); //cloudObject.SetActive (true); transform.position = cloudController.lastPosition; GameManager.Instance.Status = "PlayerSnow"; //GameObject.Instantiate(cloudObject,transform.position/* new Vector3(5.6f,12.5f,0f)*/,Quaternion.identity); } GameManager.Instance.isCameraFix = false; GameManager.Instance.isCameraReturn = true; } if (!isSnow) { transform.position = new Vector3(cloudController.lastPosition.x, outOfScreenY, 0); return; } //Store the current horizontal input in the float moveHorizontal. float moveHorizontal = Input.GetAxis ("Horizontal") * speedFactor; //Store the current vertical input in the float moveVertical. float moveVertical = 0;//Input.GetAxis ("Vertical"); movement = new Vector2 (moveHorizontal, 0); movement.x = joystick.Horizontal() * speedFactor; if (movement.x > MaxSpeed) movement.x = MaxSpeed; else if (movement.x < -MaxSpeed) movement.x = -MaxSpeed; movement.y = 0;//joystick.Vertical(); //Debug.Log (" spped " + movement.y); if (Input.GetKeyDown(KeyCode.Space)) tryJump(); bool isJumpClick = heroJump.isClickBool; if (isJumpClick) { heroJump.isClickBool = false; isJumpClick = false; isJump = !isJump; tryJump (); } // run //rb2d.AddForce (new Vector2(movement.x, 0) * speed); rb2d.velocity = new Vector2 (movement.x , rb2d.velocity.y); //jump Collider2D[] colliders = Physics2D.OverlapCircleAll(rb2d.position, ballRadius,LayerMask.GetMask("surface")); //Call the AddForce function of our Rigidbody2D rb2d supplying movement multiplied by speed to move our player. // for (int i = 0; i < colliders.Length; i++) // { // if (colliders [i].gameObject != gameObject) { // m_Grounded = true; // break; // } // } if (colliders.Length >= 1) { m_Grounded = true; //Debug.Log("colliders.Length = " + colliders.Length); } else { //Debug.Log("colliders.Length = " + colliders.Length); m_Grounded = false; } //transform.Rotate (new Vector3 (0, 0, -45) * Time.deltaTime); }
// Update is called once per frame void Update() { if (startbossfight) { startpoint = transform.position; isGrounded = Physics2D.OverlapCircle(feetpos.position, checkRadius, whatIsGround); bossanim.SetBool("isGrounded", isGrounded); if (isGrounded && !prevGrounded) { GameObject cam = GameObject.FindGameObjectWithTag("MainCamera"); FindObjectOfType <SFX>().Play("boss_stomp"); cam.GetComponent <Animator>().SetTrigger("shake"); } prevGrounded = isGrounded; if (isGrounded && boss_state == 1) { rb.velocity = new Vector2(0 * speed, rb.velocity.y); if ((transform.position.x < player.position.x) && !facingright) { flip(); } if ((transform.position.x > player.position.x) && facingright) { flip(); } } else if (die) { rb.velocity = new Vector2(0 * speed, rb.velocity.y); } else { rb.velocity = new Vector2(movedir * speed, rb.velocity.y); } time_to_changestate -= Time.deltaTime; if (time_to_changestate <= 0 && (isGrounded == true || isFlying == true)) { changestate(); time_to_changestate = changetime; } switch (boss_state) { case 1: if (timebtwjump <= 0) { jump(); timebtwjump = jumptime; } else { timebtwjump -= Time.deltaTime; } break; case 2: if (!isFlying) { isFlying = true; bossanim.SetBool("fly", isFlying); bossanim.SetTrigger("jump"); rb.velocity = Vector2.up * jumpforce; } flying(); if (timebtwattack <= 0) { rb.velocity = new Vector2(0 * speed, rb.velocity.y); bossanim.SetTrigger("attack"); attack(numberofBullet); timebtwattack = attacktime; } else { timebtwattack -= Time.deltaTime; } break; case 3: speed = 0f; if (timebtwattack <= 0) { bossanim.SetTrigger("attack"); spawnvirus(); timebtwattack = attacktime; } else { timebtwattack -= Time.deltaTime; } break; case 4: speed = 0f; if (c_attacktimecounter <= 0) { if (num > 5) { num = 0; } bossanim.SetTrigger("attack"); circularattack(c_numberofBullet[num]); c_attacktimecounter = c_attacktime; num++; } else { c_attacktimecounter -= Time.deltaTime; } break; case 5: focusonboss(); bossanim.SetTrigger("die"); break; default: break; } } }
private void Update() { // Use GetAxisRaw to ensure our input is either 0, 1 or -1. float moveInput = Input.GetAxisRaw("Horizontal"); if (grounded) { velocity.y = 0; if (Input.GetButtonDown("Jump")) { // Calculate the velocity required to achieve the target jump height. velocity.y = Mathf.Sqrt(2 * jumpHeight * Mathf.Abs(Physics2D.gravity.y)); } } float acceleration = grounded ? walkAcceleration : airAcceleration; float deceleration = grounded ? groundDeceleration : 0; if (moveInput != 0) { velocity.x = Mathf.MoveTowards(velocity.x, speed * moveInput, acceleration * Time.deltaTime); } else { velocity.x = Mathf.MoveTowards(velocity.x, 0, deceleration * Time.deltaTime); } velocity.y += Physics2D.gravity.y * Time.deltaTime; transform.Translate(velocity * Time.deltaTime); grounded = false; // Retrieve all colliders we have intersected after velocity has been applied. Collider2D[] hits = Physics2D.OverlapBoxAll(transform.position, boxCollider.size, 0); foreach (Collider2D hit in hits) { // Ignore our own collider. if (hit == boxCollider) { continue; } ColliderDistance2D colliderDistance = hit.Distance(boxCollider); // Ensure that we are still overlapping this collider. // The overlap may no longer exist due to another intersected collider // pushing us out of this one. if (colliderDistance.isOverlapped) { transform.Translate(colliderDistance.pointA - colliderDistance.pointB); // If we intersect an object beneath us, set grounded to true. if (Vector2.Angle(colliderDistance.normal, Vector2.up) < 90 && velocity.y < 0) { grounded = true; } } } }
/*--------------------------------------------------------------------------------------*/ /* */ /* FixedUpdate: Runs every fixed interval. Interval can be changed in Unity. */ /* */ /*--------------------------------------------------------------------------------------*/ void FixedUpdate() { if (!NextLevel.loadingLevel.isLoading) { if (target == null) { if (!_SerahcingForPlayer) { _SerahcingForPlayer = true; StartCoroutine(SearchForPlayer()); } return; } if (path == null) { return; } if (_CurrentWayPoint >= path.vectorPath.Count) { if (pathIsEnded) { return; } pathIsEnded = true; return; } pathIsEnded = false; // Only move when active if (!isOff) { // Movement when player is in sight or when not in the light if ((tag != "Enemy_BLCK" || !inLight) && followPlayer) { // Finds direction to next way point Vector3 direction = (path.vectorPath [_CurrentWayPoint] - transform.position).normalized; direction *= speed * Time.fixedDeltaTime; // Moves the AI _Rigidbody2D.AddForce(direction, fMode); float distance = Vector3.Distance(transform.position, path.vectorPath [_CurrentWayPoint]); if (distance < nextWayPointDistance) { _CurrentWayPoint++; return; } } // Movement for YELLOW enemies (left and right) if (!followPlayer && tag == "Enemy_YLLW") { Vector2 lineCastPosition = transform.position.toVector2() - transform.right.toVector2() * _Width + Vector2.up * _Height; bool isGrounded = Physics2D.Linecast(lineCastPosition, lineCastPosition + Vector2.down, enemyMask); bool isBlocked = Physics2D.Linecast(lineCastPosition, lineCastPosition - transform.right.toVector2() * 0.05f, enemyMask); // If not grounded or blocked then turn around if (!isGrounded || isBlocked) { Vector3 currentRotation = transform.eulerAngles; currentRotation.y += 180; transform.eulerAngles = currentRotation; } // Always move "forward" when not following player Vector2 newVelcotiy = _Rigidbody2D.velocity; newVelcotiy.x = -transform.right.x * moveSpeed * Time.fixedDeltaTime; _Rigidbody2D.velocity = newVelcotiy; } // Movement for CYAN enemies (up and down) if (!followPlayer && tag == "Enemy_CYAN") { Vector2 lineCastPosition = transform.position.toVector2() - transform.right.toVector2() * 0.0f * _Width + Vector2.up * _Height; bool isBlockedBottom = Physics2D.Linecast(lineCastPosition, lineCastPosition + Vector2.down * 0.9f, enemyMask); bool isBlockedTop = Physics2D.Linecast(lineCastPosition, lineCastPosition + Vector2.up * 0.05f, enemyMask); // If not grounded or bloacked then turn around if (isBlockedBottom || isBlockedTop) { moveSpeed *= -1; } // Always move forward when not following player Vector2 newVelcotiy = _Rigidbody2D.velocity; newVelcotiy.y = -transform.up.y * moveSpeed * Time.fixedDeltaTime; _Rigidbody2D.velocity = newVelcotiy; } } } }
// Update is called once per frame void Update() { Vector3 vec = Vector3.right * transform.localScale.x; //int offset = 0; for (int i = 0; i < m_shootingSide.Length; i++) { for (int j = 0; j < m_halfSideBulletNumber; j++) { Vector3 angle = Quaternion.AngleAxis(m_shootingSide [i] * (j + 1) * m_angleInterval, Vector3.forward) * vec; Vector3 end = transform.position + angle * m_rayLength; Debug.DrawLine(transform.position, end, Color.red); hit = Physics2D.Raycast(transform.position, angle, m_rayLength, m_layer); if (hit.collider != null) { //m_vertices [i * m_halfSideBulletNumber + j + offset] = new Vector2 (hit.point.x - transform.position.x, hit.point.y - transform.position.y); if (hit.collider.name == "Hero") { LoadController load = GameObject.Find("SavaPoint").GetComponent <LoadController> (); load.Reload(hit.collider.gameObject); } } else { //m_vertices [i * m_halfSideBulletNumber + j + offset] = angle * m_rayLength; } //input //求法线向量与物体上方向向量点乘,结果为1或-1,修正旋转方向 //float aAngle = Vector3.Angle (Vector3.right, angle) * Mathf.Sign (Vector3.Dot (angle, Vector3.up)); //aSimpleBullet.transform.Rotate (Vector3.forward, aAngle); //aSimpleBullet.m_isPlayerFire = m_isPlayerFire; //aSimpleBullet.InitBullet (angle, m_bulletSpeed, m_bulletAttack, m_bulletDuration, m_bulletRepelDistance); } //offset += 1; } Debug.DrawLine(transform.position, (transform.position + vec * m_rayLength), Color.red); hit = Physics2D.Raycast(transform.position, vec * m_rayLength, m_rayLength, m_layer); if (hit.collider != null) { //m_vertices [m_halfSideBulletNumber -2] = new Vector2 (hit.point.x - transform.position.x, hit.point.y - transform.position.y); if (hit.collider.name == "Hero") { LoadController load = GameObject.Find("SavaPoint").GetComponent <LoadController> (); load.Reload(hit.collider.gameObject); } } else { //m_vertices [(i + 1) * m_halfSideBulletNumber] = vec * m_rayLength; } //m_vertices [m_vertices.Length - 1] = Vector3.zero; //Vector2 temp = m_vertices [1]; //m_vertices [1] = m_vertices [0]; //m_vertices [0] = temp; //Vector3 [] vertices3D = System.Array.ConvertAll<Vector2, Vector3> (m_vertices, v => v); //// Use the triangulator to get indices for creating triangles //Triangulator triangulator = new Triangulator (m_vertices); //int [] indices = triangulator.Triangulate (); //Color [] colors = new Color [vertices3D.Length]; //for (int i = 0; i < colors.Length; i++) { // colors [i] = Color.red; // colors [i].a = 0.5f; //} //// Create the mesh //var mesh = new Mesh { // vertices = vertices3D, // triangles = indices, // colors = colors //}; //mesh.RecalculateNormals (); //mesh.RecalculateBounds (); //filter.mesh = mesh; }
void FixedUpdate() { isGrounded = Physics2D.OverlapCircle(groundCheck.position, groundRadius, whatIsGround); }
void FixedUpdate() { Grounded = Physics2D.OverlapCircle(GroundCheck.position, GroundCheckRadius, WhatIsGround); }
private bool Cast(Collider2D col) { return(!Physics2D.Raycast(Origin.position, col.transform.position - Origin.position, Vector2.Distance(col.transform.position, Origin.position), LayerMask).collider); }
void FixedUpdate() { Walled = Physics2D.OverlapCircle(wallCheck.position, WallRadius, WhatIsWall); notAtEg = Physics2D.OverlapCircle(egCheck.position, WallRadius, WhatIsWall); }
protected override IEnumerator abilityActionSequence() { caster.rb2D.AddForce(direction * abilityVelocity / Time.timeScale); while (!caster.getAttackTrigger().hasAttackTriggered()) yield return null; caster.getAttackTrigger().resetTrigger(); //Check if attack can go through if (!caster.isDead()) { Vector2 newPos = new Vector2(caster.transform.position.x, caster.transform.position.y + caster.objectHeight / 2); RaycastHit2D[] hitObject = Physics2D.RaycastAll(newPos, direction, abilityRange, CMoveCombatable.attackMask, -10, 10); Debug.DrawRay(newPos, direction * abilityRange, Color.red, 3f); bool hitTarget = false; //If the Raycast hits an object on the layer Enemy foreach (RaycastHit2D r in hitObject) { if (r && r.transform.gameObject != caster.gameObject) { //If an object has been hit first if (r.transform.gameObject.tag == "Object") { if (r.collider.isTrigger) continue; else break; } //Hit attack CHitable objectHit = r.transform.gameObject.GetComponentInParent<CHitable>(); if (objectHit.tag == caster.tag) continue; //Apply damage and knockback objectHit.setAttacker(caster); objectHit.knockback(pos, abilityKnockback, objectHit.objectHeight); //Need to use original pos for knockback so the position of where you attacked from is the knockback objectHit.knockUp(pos, abilityKnockback, abilityKnockUp, objectHit.objectHeight); objectHit.loseHealth(abilityDamage); CMoveCombatable targetHit = r.transform.gameObject.GetComponentInParent<CMoveCombatable>(); if (targetHit != null) { targetHit.causeOfDeath = causeOfDeath; } caster.audioSource.clip = caster.attackSound; caster.audioSource.Play(); caster.attackHit(); hitTarget = true; break; } } if (!hitTarget) { caster.audioSource.clip = caster.missSound; caster.audioSource.Play(); } if (caster.pauseAfterAttack < 0.5f) yield return new WaitForSeconds(0.5f); else yield return new WaitForSeconds(caster.pauseAfterAttack); } caster.canMove = true; caster.attacking = false; caster.canCombo = false; }
// FixUpdate is called once 0.02 seconds each frame (This can be modified in edit > Project Settings > Time > Fixed Timestep) void FixedUpdate() { //MOVIMIENT HORIZONTAL inputX = Input.GetAxis("Horizontal"); if (!agachado && !mirarArriba) { transform.position += new Vector3(inputX * velX * Time.deltaTime, 0, 0); posIniIFin = Mathf.Clamp(transform.position.x, -14.32f, 205f); transform.position = new Vector3(posIniIFin, transform.position.y, 0); if (inputX > 0) { transform.localScale = new Vector3(1, 1, 1); } if (inputX < 0) { transform.localScale = new Vector3(-1, 1, 1); } } if (inputX != 0) { animator.SetFloat("velX", 1); } else { animator.SetFloat("velX", 0); } //SALT enSuelo = Physics2D.OverlapCircle(pie.position, radioPie, suelo); //AJUPITSE if (enSuelo && (Input.GetKey(KeyCode.DownArrow) || Input.GetButton("Vertical"))) { agachado = true; animator.SetBool("agachado", true); gameObject.GetComponent <CircleCollider2D>().offset = new Vector2(0f, 0.16f); gameObject.GetComponent <CircleCollider2D>().radius = 0.15f; } else { gameObject.GetComponent <CircleCollider2D>().offset = new Vector2(0.03853655f, 0.2803588f); gameObject.GetComponent <CircleCollider2D>().radius = 0.2048309f; if (Input.GetKeyUp(KeyCode.DownArrow)) { gameObject.GetComponent <CircleCollider2D>().offset = new Vector2(0.03853655f, 0.2803588f); gameObject.GetComponent <CircleCollider2D>().radius = 0.2048309f; } agachado = false; animator.SetBool("agachado", false); } //MIRAR AMUNT if (inputX == 0) //Si no me muevo { if (enSuelo && (Input.GetKey(KeyCode.UpArrow) || Input.GetButton("Fire3"))) { mirarArriba = true; animator.SetBool("mirarArriba", true); } else { mirarArriba = false; animator.SetBool("mirarArriba", false); } } //CAIGUDA caida = rb.velocity.y; if (caida != 0 || caida == 0) { animator.SetFloat("velY", caida); } //CORRER if (inputX != 0) { if (Input.GetKey(KeyCode.X) || Input.GetButton("Fire2")) { run = true; velX = 0f; animator.SetBool("run", true); } if (!Input.GetKey(KeyCode.X) || !Input.GetButton("Fire2")) { velX = 4f; run = false; animator.SetBool("run", false); } } else { run = false; animator.SetBool("run", false); } }
/* Creates grid map based on the start and end position of the grid */ private void CreateMap() { //Find positions for start and end of map float startX = MapStartPosition.x; float startY = MapStartPosition.y; float endX = MapEndPosition.x; float endY = MapEndPosition.y; //Find tile width and height width = (int)Mathf.Floor((endX - startX) / Tilesize); height = (int)Mathf.Floor((endY - startY) / Tilesize); //Create double array representing the nodes in the grid Map = new AStarNode[width, height]; Vector2 nodePosition = new Vector2(); Vector2 boxCastSize = new Vector2(Tilesize / 2, Tilesize / 2); //Create nodes in the map for (int i = 0; i < width; i++) { for (int j = 0; j < height; j++) { //Compute nodes position nodePosition.x = startX + (i * Tilesize); nodePosition.y = startY + (j * Tilesize); //Create a node at that position Map[i, j] = new AStarNode(nodePosition, true); //Ray cast to see if there is a 2D collider at that position RaycastHit2D[] hit2D = Physics2D.BoxCastAll(nodePosition, boxCastSize, 0f, Vector2.left, 0f); //For any 2D collider found at the position, check if the associated game object //is tagged with one of the disallowed tags foreach (RaycastHit2D h in hit2D) { //If tagged with a tag on the disallowed tags list, make the node //non-walkable if (CheckForDisallowedTag(h.transform)) { Map[i, j].walkable = false; break; } } } } //Given the 2D array of nodes, connect the neighbouring tiles. There can be a maximum of //eight connections from a given node: up and down, left and right, left-down, left-up, right-down and right-up for (int i = 0; i < width; i++) { for (int j = 0; j < height; j++) { //Get the node from the map AStarNode nodeLeft = Map[i, j]; //Check if the node is walkable if (!nodeLeft.walkable) { continue; } //Cycle through all the neighbours of the node (based on 2D arrangement) for (int ni = i - 1; ni <= i + 1; ni++) { if (ni < 0 || ni >= width) { continue; } for (int nj = j - 1; nj <= j + 1; nj++) { if (nj < 0 || nj >= height) { continue; } AStarNode nodeRight = Map[ni, nj]; //Do not connect to self if (nodeRight == nodeLeft) { continue; } //If the neighbour is not walkable, do not connect if (!nodeRight.walkable) { continue; } //Do not connect the same node twice if (nodeLeft.isConnected(nodeRight)) { continue; } //The weight of the connection is the Eucledean distance between //the nodes float cost = Vector2.Distance(nodeLeft.position, nodeRight.position); //Connect the nodes nodeLeft.connect(nodeRight, cost); } } //Sort the game nodes by cost - this will speed up pathfinding later on nodeLeft.neighbours = nodeLeft.neighbours.OrderBy(x => x.cost).ToList(); } } }
private bool CanGetUp() { return(Physics2D.OverlapBox(transform.position + attributes.colliderBounds.center, attributes.colliderBounds.extents - (Vector3.one * .001f), 0, contactFilter, overlapBuffer) == 0); }
public void SideCheck() { int rays = 4; //bool firstLeft = false; //bool lastLeft = false; //bool firstRight = false; //bool lastRight = false; for (int i = 0; i < rays; i++) { //left Vector2 leftPos = new Vector2(_Collider.bounds.min.x, _Collider.bounds.min.y) + new Vector2(0, 1) * _Collider.bounds.size.y / (rays - 1) * i; Debug.DrawRay(leftPos, -transform.right * 0.2f, Color.red); RaycastHit2D leftHit = Physics2D.Raycast(leftPos, -transform.right, 0.2f, _StandableMasks); if (leftHit) { //if (i == 0) //{ // firstLeft = true; //} //if (i == rays -1) //{ // lastLeft = true; //} if (_Velocity.x < 0) { _Velocity.x = 0; } } //right Vector2 rightPos = new Vector2(_Collider.bounds.max.x, _Collider.bounds.min.y) + new Vector2(0, 1) * _Collider.bounds.size.y / (rays - 1) * i; Debug.DrawRay(rightPos, transform.right * 0.2f, Color.red); RaycastHit2D rightHit = Physics2D.Raycast(rightPos, transform.right, 0.2f, _StandableMasks); if (rightHit) { //if (i == 0) //{ // firstRight = true; //} //if (i == rays -1) //{ // lastRight = true; //} if (_Velocity.x > 0) { _Velocity.x = 0; } } } //if (firstLeft == true && lastLeft == false) //{ // if (InputManager.instance.HorizontalDirection() == -1) // { // _Velocity.y = 10; // } //} //else //{ //} //if (firstRight == true && lastRight == false) //{ // if (InputManager.instance.HorizontalDirection() == 1) // { // _Velocity.y = 10; // } //} //else //{ //} }
void VerticalCollisions(ref Vector2 moveAmount, bool jumpInputDown) //similiar to horizontal but with a few differences, especially with through platforms. Also stores standing on top of if on one { float directionY = Mathf.Sign(moveAmount.y); float rayLength = Mathf.Abs(moveAmount.y) + SKIN_WIDTH; if (Mathf.Abs(moveAmount.y) < SKIN_WIDTH) { rayLength = 2 * SKIN_WIDTH; } for (int i = 0; i < verticalRayCount; i++) { Vector2 rayOrigin = (directionY == -1) ? raycastOrigins.bottomLeft : raycastOrigins.topLeft; rayOrigin += Vector2.right * (verticalRaySpacing * i + moveAmount.x); RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up * directionY, rayLength, collisionMask); Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.red); if (hit) { if (hit.collider.tag == "Through") { if (directionY == 1 || hit.distance == 0) //if moving up, continue to next ray. (only collides of moving down) { continue; } if (collisions.fallingThrough == true && collisions.fallingThroughPlatform == hit.collider) //if the user if falling through the platform { continue; } if (directionalInput.y == -1) //enables the user to drop through the platform after they press down { collisions.readyToFallThrough = true; } if (directionalInput.y == -1 && jumpInputDown) //drops through the platform { if (hit.collider == collisions.fallingThroughPlatform) { collisions.fallingThrough = true; continue; } } } collisions.fallingThrough = false; //if made it through the last if statement, the user isn't falling through the platform collisions.fallingThroughPlatform = hit.collider; //sets the platform the user is standing on top of, important for if the user does fall through it, it stores it and resets it when landing on another platform moveAmount.y = (hit.distance - SKIN_WIDTH) * directionY; rayLength = hit.distance; if (collisions.climbingSlope) { //math here: https://www.youtube.com/watch?v=cwcC2tIKObU moveAmount.x = moveAmount.y / Mathf.Tan(collisions.slopeAngle * Mathf.Deg2Rad) * Mathf.Sign(moveAmount.x); } collisions.below = directionY == -1; collisions.above = directionY == 1; } } //chicking for collisions when climbing a slope...? if (collisions.climbingSlope) { float directionX = Mathf.Sign(moveAmount.x); rayLength = Mathf.Abs(moveAmount.x) + SKIN_WIDTH; Vector2 rayOrigin = ((directionX == -1) ? raycastOrigins.bottomLeft : raycastOrigins.bottomRight) + Vector2.up * moveAmount.y; RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, collisionMask); if (hit) { float slopeAngle = Vector2.Angle(hit.normal, Vector2.up); if (slopeAngle != collisions.slopeAngle) { moveAmount.x = (hit.distance - SKIN_WIDTH) * directionX; collisions.slopeAngle = slopeAngle; collisions.slopeNormal = hit.normal; } } } }
// Update is called once per frame public virtual void Update() { // Less maneouvrability in the air if (isGrounded || verticalMoveEnabled) { currentAccelerationX = accelerationX; currentAccelerationY = accelerationY; } else { currentAccelerationX = accelerationX / 2; currentAccelerationY = accelerationY / 2; } float positionX = transform.position.x; float positionY = transform.position.y; // Update the speed X if (currentSpeedX < wantedSpeedX) { currentSpeedX = Mathf.Min(wantedSpeedX, currentSpeedX + (accelerationX * Time.deltaTime)); } else if (currentSpeedX > wantedSpeedX) { currentSpeedX = Mathf.Max(wantedSpeedX, currentSpeedX - (accelerationX * Time.deltaTime)); } // Update the speed Y if (verticalMoveEnabled) { if (currentSpeedY < wantedSpeedY) { currentSpeedY = Mathf.Min(wantedSpeedY, currentSpeedY + (accelerationY * Time.deltaTime)); } else if (currentSpeedY > wantedSpeedY) { currentSpeedY = Mathf.Max(wantedSpeedY, currentSpeedY - (accelerationY * Time.deltaTime)); } } // Update the position X if (!Mathf.Approximately(currentSpeedX, 0)) { positionX += currentSpeedX * Time.deltaTime; } // Update the position Y if (verticalMoveEnabled) { if (!Mathf.Approximately(currentSpeedY, 0)) { positionY += currentSpeedY * Time.deltaTime; } } transform.position = new Vector3(positionX, positionY); // Overlap ground check // Make a rectangle out of two edges (Vector 2) and if that rectangle overlaps with layer (8) it returns true if (boxCollider) { var hitboxHalf = boxCollider.bounds.size.x / 2; isGrounded = Physics2D.OverlapArea( new Vector2(transform.position.x - hitboxHalf, transform.position.y), new Vector2(transform.position.x + hitboxHalf, transform.position.y - 0.02f), 1 << 8); animator.SetBool("Grounded", isGrounded); } // For animation in the air if (body) { animator.SetFloat("SpeedY", body.velocity.y); } }
void HorizontalCollisions(ref Vector2 moveAmount, bool jumpInputDown) { float directionX = collisions.faceDirection; float rayLength = Mathf.Abs(moveAmount.x) + SKIN_WIDTH; //if not moving, check for collisions on the side by a minor amount (usually for wall sliding) if (Mathf.Abs(moveAmount.x) < SKIN_WIDTH) { rayLength = 2 * SKIN_WIDTH; } //the jumpinputdown variable is for the frame that the player jumps, a ray is not cast from the bottom of the collision, so they won't collide with any slopes and stutter their jump //each of the for loops in these sections is to check collissions on each of the rays that are drawn on the colllider for (int i = (!jumpInputDown)?0:1; i < horizontalRayCount; i++) { Vector2 rayOrigin = (directionX == -1) ? raycastOrigins.bottomLeft : raycastOrigins.bottomRight; rayOrigin += Vector2.up * (horizontalRaySpacing * i); RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, collisionMask); Debug.DrawRay(rayOrigin, Vector2.right * directionX * rayLength, Color.red); if (hit) { //if hitting a through obstacle from the side, continue (go to the next part of the for loop, in this case, the next ray if (hit.collider.tag == "Through") { continue; } //if inside the obstacle, usually in the case of a moving block that pushes you into a solid one if (hit.distance == 0) { continue; } //slopes that the user can climb float slopeAngle = Vector2.Angle(hit.normal, Vector2.up); if (i == 0 && slopeAngle <= maxSlopeAngle) { if (collisions.descendingSlope) { collisions.descendingSlope = false; moveAmount = collisions.moveAmountOld; } float distanceToSlopeStart = 0; if (slopeAngle != collisions.slopeAngleOld) { distanceToSlopeStart = hit.distance - SKIN_WIDTH; moveAmount.x -= distanceToSlopeStart * directionX; } ClimbSlope(ref moveAmount, slopeAngle, hit.normal); moveAmount.x += distanceToSlopeStart * directionX; } //normal collision if (!collisions.climbingSlope || slopeAngle > maxSlopeAngle) { moveAmount.x = (hit.distance - SKIN_WIDTH) * directionX; rayLength = hit.distance; if (collisions.climbingSlope) { //math here: https://www.youtube.com/watch?v=cwcC2tIKObU moveAmount.y = Mathf.Tan(collisions.slopeAngle * Mathf.Deg2Rad) * Mathf.Abs(moveAmount.x); } collisions.left = directionX == -1; collisions.right = directionX == 1; } } } }
public void Move(float move, bool crouch, bool jump) { // If crouching, check to see if the character can stand up if (!crouch) { // If the character has a ceiling preventing them from standing up, keep them crouching if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround)) { crouch = true; } } //only control the player if grounded or airControl is turned on if (m_Grounded || m_AirControl) { // If crouching if (crouch) { if (!m_wasCrouching) { m_wasCrouching = true; OnCrouchEvent.Invoke(true); } // Reduce the speed by the crouchSpeed multiplier move *= m_CrouchSpeed; // Disable one of the colliders when crouching if (m_CrouchDisableCollider != null) m_CrouchDisableCollider.enabled = false; } else { // Enable the collider when not crouching if (m_CrouchDisableCollider != null) m_CrouchDisableCollider.enabled = true; if (m_wasCrouching) { m_wasCrouching = false; OnCrouchEvent.Invoke(false); } } // Move the character by finding the target velocity Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y); // And then smoothing it out and applying it to the character m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing); // If the input is moving the player right and the player is facing left... if (move > 0 && !m_FacingRight) { // ... flip the player. Flip(); } // Otherwise if the input is moving the player left and the player is facing right... else if (move < 0 && m_FacingRight) { // ... flip the player. Flip(); } } // If the player should jump... if (m_Grounded && jump) { // Add a vertical force to the player. m_Grounded = false; m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce)); } }
/** Returns if the connection between \a a and \a b is valid. * Checks for obstructions using raycasts (if enabled) and checks for height differences.\n * As a bonus, it outputs the distance between the nodes too if the connection is valid */ public virtual bool IsValidConnection(GraphNode a, GraphNode b, out float dist) { dist = 0; if (!a.Walkable || !b.Walkable) { return(false); } var dir = (Vector3)(b.position - a.position); if ( (!Mathf.Approximately(limits.x, 0) && Mathf.Abs(dir.x) > limits.x) || (!Mathf.Approximately(limits.y, 0) && Mathf.Abs(dir.y) > limits.y) || (!Mathf.Approximately(limits.z, 0) && Mathf.Abs(dir.z) > limits.z)) { return(false); } dist = dir.magnitude; if (maxDistance == 0 || dist < maxDistance) { if (raycast) { var ray = new Ray((Vector3)a.position, dir); var invertRay = new Ray((Vector3)b.position, -dir); if (use2DPhysics) { if (thickRaycast) { return(!Physics2D.CircleCast(ray.origin, thickRaycastRadius, ray.direction, dist, mask) && !Physics2D.CircleCast(invertRay.origin, thickRaycastRadius, invertRay.direction, dist, mask)); } else { return(!Physics2D.Linecast((Vector2)(Vector3)a.position, (Vector2)(Vector3)b.position, mask) && !Physics2D.Linecast((Vector2)(Vector3)b.position, (Vector2)(Vector3)a.position, mask)); } } else { if (thickRaycast) { return(!Physics.SphereCast(ray, thickRaycastRadius, dist, mask) && !Physics.SphereCast(invertRay, thickRaycastRadius, dist, mask)); } else { return(!Physics.Linecast((Vector3)a.position, (Vector3)b.position, mask) && !Physics.Linecast((Vector3)b.position, (Vector3)a.position, mask)); } } } else { return(true); } } return(false); }
private void CheckGrounded() { RaycastHit2D hit = Physics2D.BoxCast(groundCheck.bounds.center, groundCheck.bounds.size, 0f, Vector2.down, 0f, collisionMask); grounded = hit.collider != null; }
void Update() { #region KeyboardInput if (Application.platform == RuntimePlatform.WindowsEditor || Application.platform == RuntimePlatform.WindowsPlayer) { if (Input.GetKeyUp(KeyCode.P)) { switch (_isPaused) { case false: Pause(true); break; case true: Pause(false); break; } } } #endregion #region TouchscreenInput if (Application.platform == RuntimePlatform.Android) { if (Input.touchCount > 0) { Vector3 touchPosition = Camera.main.ScreenToWorldPoint(Input.GetTouch(0).position); Vector2 touchPosition2D = new Vector2(touchPosition.x, touchPosition.y); RaycastHit2D hit = Physics2D.Raycast(touchPosition2D, Vector2.zero); if (hit) { if (hit.collider.gameObject.CompareTag("ButtonPause") && (Input.GetTouch(0).phase == TouchPhase.Ended || Input.GetTouch(0).phase == TouchPhase.Canceled)) { switch (_isPaused) { case false: Pause(true); break; case true: Pause(false); break; } } } } if (Input.GetKeyUp(KeyCode.Escape)) { switch (_isPaused) { case false: Pause(true); break; case true: player.GetComponent <Player>().SaveScore(); sceneGameManager.GetComponent <SceneGameManager>().scene = "Main Menu"; sceneGameManager.GetComponent <SceneGameManager>().fadeAnimator.SetTrigger("fadeOut"); Time.timeScale = 1; break; } } } #endregion }
public void ActionHandler() { if (state == States.None) { if (IsMouseButtonPressed() && GetClickedObject().name != ".") { PickUp(); Debug.Log(item.name); } } else { if (IsMouseButtonPressed()) { Drag(); } else { Drop(); } } bool IsMouseButtonPressed() { return(Input.GetMouseButton(0)); } void Drop() { toPosition = item.transform.position; DropObject(fromPosition, toPosition); item = null; state = States.None; } void Drag() { item.transform.position = GetClickPosition(); } void PickUp() { Vector2 clickPosition = GetClickPosition(); Transform clickedItem = GetItemAt(clickPosition); if (clickedItem == null) { return; } state = States.Drag; item = clickedItem.gameObject; fromPosition = clickedItem.position; offset = fromPosition - clickPosition; PickObject(fromPosition); } Vector2 GetClickPosition() { return(Camera.main.ScreenToWorldPoint(Input.mousePosition)); } Transform GetItemAt(Vector2 position) { RaycastHit2D[] figures = Physics2D.RaycastAll(position, position, 0.5f); if (figures.Length == 0) { return(null); } return(figures[0].transform); } GameObject GetClickedObject() { Vector2 clickPosition = GetClickPosition(); Transform clickedItem = GetItemAt(clickPosition); return(clickedItem.gameObject); } }
private bool IsWithinReach(Vector2 pos, Vector2 damageablePos, float distance) { return(distance <= radius && Physics2D.Raycast(pos, damageablePos - pos, distance, OBSTACLE_MASK).collider == null); }