private void FixedUpdate() { if (!m_can_damage) { return; } Vector2 scale = m_transform.lossyScale; Vector2 facingOffset = Vector2.Scale(offset, scale); if (m_sprite_renderer != null && m_sprite_renderer.flipX != m_origin_flip) { facingOffset = new Vector2(-offset.x * scale.x, offset.y * scale.y); } Vector2 scaledSize = Vector2.Scale(size, scale); Vector2 pointA = (Vector2)m_transform.position + facingOffset - scaledSize * 0.5f; Vector2 pointB = pointA + scaledSize; Array.Clear(m_hits, 0, m_hits.Length); int hitCount = Physics2D.OverlapAreaNonAlloc(pointA, pointB, m_hits, hittable_layers); for (int i = 0; i < hitCount; i++) { /// TODO : 몬스터 스크립트 가져와서 데미지 주는거 추가해야함 float calcHp = m_hits[i].GetComponent <CharacterComponent>().unit.rank.current_hp - m_character.unit.rank.damage; m_hits[i].GetComponent <CharacterComponent>().unit.rank.SetCurrentHp(calcHp); } m_can_damage = false; }
void BallCollision(Collision2D coll) { Vector2 pointA, pointB; pointA = new Vector2(transform.position.x, transform.position.y); pointB = new Vector2(transform.position.x, transform.position.y); pointA.x += velocity.x / speed / Time.fixedDeltaTime; pointA.y += velocity.y / speed / Time.fixedDeltaTime; pointB.x -= velocity.x / speed / Time.fixedDeltaTime; pointB.y += velocity.y / speed / Time.fixedDeltaTime; GameObject a = GameObject.CreatePrimitive(PrimitiveType.Sphere); GameObject b = GameObject.CreatePrimitive(PrimitiveType.Sphere); a.transform.position = pointA; b.transform.position = pointB; int layerID = LayerMask.NameToLayer("Tetroid"); // 0-31 int layerMask = 1 << layerID; layerID = LayerMask.NameToLayer("Tetris"); layerMask = layerMask | 1 << layerID; int num = Physics2D.OverlapAreaNonAlloc(pointA, pointB, colliders, layerMask); Debug.LogError(""); //Destroy (a); //Destroy (b); }
void Update() { ClearPoints(); int counts = Physics2D.OverlapAreaNonAlloc(leftP, right.position, cs, layer); HitToSetPoints(cs, counts); }
// Update is called once per frame void Update() { if (IsOn) { int isAnyCollision = 0; Collider2D[] collider = new Collider2D[2]; switch (colliderCheckerType) { case ColliderCheckerType.RectangleArea: //metoda nie alokuje pamieci, bierze tylko to co jej dalismy (wychodzi na to, ze zwracany wynik tez jest zalezny od tej tablicy //jaka mu przekazemy, pewnie zwraca cos w rodzaju array.Length isAnyCollision = Physics2D.OverlapAreaNonAlloc(_UpperLeftCorner, _LowerRightCorner, collider, 1 << this.gameObject.layer); break; case ColliderCheckerType.CircleArea: isAnyCollision = Physics2D.OverlapCircleNonAlloc(collider2D.renderer.bounds.center, collider2D.renderer.bounds.size.x / 2, null, 1 << this.gameObject.layer); break; default: return; } //na to wyglada, ze on sam siebie tez bierze pod uwage O.o if (isAnyCollision > 1) { isAnyCollision = 0; _scriptStartInterface.StartInterface(); } PreviousPosition = transform.position; //rozwiazanie troche na skroty, ale w tym momencie chyba najlepsze :D //inaczej bym musial sie dostawac do wszystkich elementow, z ktorym obiekt ma kolizje //i wyznaczac dokladniejsza pozycje } }
Rigidbody2D GetBodyAtTouch(ref InputInfo info) { // Make a box var lowerBound = new Vector2(info.worldPosition.x - info.worldDistance, info.worldPosition.y - info.worldDistance); var upperBound = new Vector2(info.worldPosition.x + info.worldDistance, info.worldPosition.y + info.worldDistance); Rigidbody2D body = null; // Query the world for overlapping shapes int queryCount = Physics2D.OverlapAreaNonAlloc( lowerBound, upperBound, m_QueryColliders, m_EnabledOnLayers); for (int i = 0; i < queryCount; ++i) { body = m_QueryColliders[i].attachedRigidbody; if (body) { break; } } return(body); }
protected override void FixedUpdate() { base.FixedUpdate(); var pos = (Vector2)transform.position; var wasGrounded = isGrounded; isGrounded = Physics2D.OverlapAreaNonAlloc(pos + feetA, pos + feetB, dumbColliders, groundLayers) > 0; if (isGrounded) { transform.parent = dumbColliders[0].transform; } else { transform.parent = null; } var mirror = new Vector2(-1, 1); var isGrippingRight = Physics2D.OverlapAreaNonAlloc(pos + handA, pos + handB, dumbColliders, groundLayers) > 0; var isGrippingLeft = Physics2D.OverlapAreaNonAlloc(pos + Vector2.Scale(handA, mirror), pos + Vector2.Scale(handB, mirror), dumbColliders, groundLayers) > 0; if (isGrounded && RemainingJumps > 0) { canAirJump = true; } var horizontal = Input.GetAxis("Horizontal"); if (isGrippingRight) { horizontal = Mathf.Clamp(horizontal, float.NegativeInfinity, 0); } if (isGrippingLeft) { horizontal = Mathf.Clamp(horizontal, 0, float.PositiveInfinity); } var sign = Mathf.Sign(horizontal); animator.SetBool("Mirror", sign < 0); animator.SetBool("IsWalking", Mathf.Abs(horizontal) > 0.3f); animator.SetBool("IsGrounded", isGrounded); animator.SetFloat("Vertical Speed", rigidbody2D.velocity.y); landSpeed = Mathf.Min(rigidbody2D.velocity.y, landSpeed); if (isGrounded && !wasGrounded) { animator.SetFloat("Land Speed", landSpeed); landSpeed = 0; // Reset Remaining Jumps RemainingJumps = TotalJumps; } rigidbody2D.velocity = new Vector2(horizontal * speed, rigidbody2D.velocity.y); }
/// <summary> /// check colliders if exist it use movetargetline on this object /// return possibilty to move object in the direction /// </summary> protected void moveSideElements(bool toRight) { int layer = gameObject.layer; gameObject.layer = 1; if (toRight) { pushCollision = Physics2D.OverlapAreaNonAlloc( new Vector2(transform.position.x - sideRadius + width / 2, transform.position.y + width / 2 - 0.1f), new Vector2(transform.position.x + sideRadius + width / 2, transform.position.y - width / 2 + 0.1f), pushColliders, whatIsMoveable); } else { pushCollision = Physics2D.OverlapAreaNonAlloc( new Vector2(transform.position.x - sideRadius - width / 2, transform.position.y + width / 2 - 0.1f), new Vector2(transform.position.x + sideRadius - width / 2, transform.position.y - width / 2 + 0.1f), pushColliders, whatIsMoveable); } gameObject.layer = layer; for (int i = 0; i < pushCollision; i++) { pushColliders[i].GetComponent <VerticalLines>().MoveTargetLine(toRight); } return; }
void CheckWeight() { Collider2D[] _weightsArray = new Collider2D[10]; Physics2D.OverlapAreaNonAlloc(collider2D.bounds.max, collider2D.bounds.min, _weightsArray); currWeight = 0; foreach (Collider2D col in _weightsArray) { if (col != null) { if (col.gameObject.layer == 11 && GameObject.FindObjectOfType <Telekinesis>().heldObj != col.gameObject) { currWeight += col.GetComponent <Weight>().weight; } if (col.gameObject.tag == "Player") { currWeight += col.transform.GetComponent <Weight>().weight; } } } _normalWeight = currWeight / maxWeight; //get normailzed weight value _normalWeight = 1 - _normalWeight; //invert value to match scale _targetHeight = (_minHeight + (_normalWeight * (_maxHeight - _minHeight))); //set Target height to normal value, realsied in worldSpace }
void CheckScales() { Collider2D[] weights1 = new Collider2D[10]; Physics2D.OverlapAreaNonAlloc(weight1.collider2D.bounds.max, weight1.collider2D.bounds.min, weights1); currWeight1 = 0; foreach (Collider2D col in weights1) { if (col != null) { if (col.gameObject.layer == 11 && GameObject.FindObjectOfType <Telekinesis>().heldObj != col.gameObject) { currWeight1 += col.GetComponent <Weight>().weight; } if (col.tag == "Player") { currWeight1 += col.transform.GetComponent <Weight>().weight; } } } Collider2D[] weights2 = new Collider2D[10]; Physics2D.OverlapAreaNonAlloc(weight2.collider2D.bounds.max, weight2.collider2D.bounds.min, weights2); currWeight2 = 0; foreach (Collider2D col in weights2) { if (col != null) { if (col.gameObject.layer == 11 && GameObject.FindObjectOfType <Telekinesis>().heldObj != col.gameObject) { currWeight2 += col.GetComponent <Weight>().weight; } if (col.tag == "Player") { currWeight2 += col.transform.GetComponent <Weight>().weight; } } } currFullWeight = 0; currFullWeight = currWeight1 + currWeight2; //Set current weight of both scales combined if (currFullWeight > 0) { float newWeight1 = currWeight2 / currFullWeight; float newWeight2 = currWeight1 / currFullWeight; currWeight1 = newWeight1; currWeight2 = newWeight2; targetHeight1 = minHeight + (currWeight1 * (maxHeight - minHeight)); targetHeight2 = minHeight + (currWeight2 * (maxHeight - minHeight)); } else { targetHeight1 = minHeight + (0.5f * (maxHeight - minHeight)); targetHeight2 = minHeight + (0.5f * (maxHeight - minHeight)); } }
private void CollidePoint(int layerMask, Vector2 offset, Vector2 displacement, Action <Vector2> resolution) { Vector2 position = new Vector2(transform.position.x, transform.position.y); nonAlloc[0] = null; Physics2D.OverlapAreaNonAlloc(position + offset, position + offset + displacement, nonAlloc, layerMask); if (nonAlloc[0] != null) { resolution(displacement); } }
public bool isGrounded() { // print ("ground"); if (Physics2D.OverlapAreaNonAlloc(leftmost.position, rightmost.position, platforms, staticCollider) > 0) { return(true); } else { return(false); } }
public int overlapAreaAll(Collider2D[] hits) { BoxCollider2D collider = GetComponent <BoxCollider2D>(); if (collider == null) { return(0); } Vector2 topLeft = (Vector2)transform.position + collider.offset - new Vector2(collider.size.x / 2, collider.size.y / 2); Vector2 botRight = (Vector2)transform.position + collider.offset + new Vector2(collider.size.x / 2, collider.size.y / 2); return(Physics2D.OverlapAreaNonAlloc(topLeft, botRight, hits)); }
public int OverlapAreaNonAlloc(Vector2 areaSize, LayerMask thingsToHit, ref Collider2D[] results) { Vector2 topLeft; topLeft.x = transform.position.x - (areaSize.x / 2); topLeft.y = transform.position.y + (areaSize.y / 2); Vector2 bottomRight; bottomRight.x = transform.position.x + (areaSize.x / 2); bottomRight.y = transform.position.y - (areaSize.y / 2); return(Physics2D.OverlapAreaNonAlloc(topLeft, bottomRight, results, thingsToHit)); }
public override IList GetCurrentTrigger() { if (!enabled) { m_len = 0; } else { Bounds bds = rect.bounds; m_len = Physics2D.OverlapAreaNonAlloc(bds.min, bds.max, m_results, checkLayer); } return(m_results); }
private void FixedUpdate() { thisTransform.localPosition += new Vector3(0f, speed * Time.fixedDeltaTime, 0f); int count = Physics2D.OverlapAreaNonAlloc((-1f / 2f) * size + thisTransform.position, (1f / 2f) * size + thisTransform.position, colliderHitBuffer, enemyLayer); for (int i = 0; i < count; i++) { colliderHitBuffer[i].GetComponent <BaseEnemy>().health--; //Debug.Log("Hit"); } if (count > 0) { Destroy(gameObject); } }
void FixedUpdate() { Bounds box = GetFloorTestBox(); int numColliders = Physics2D.OverlapAreaNonAlloc(box.min, box.max, overlappingColliders); isTouchingGround = false; for (int i = 0; i < numColliders; i++) { if (overlappingColliders[i].gameObject != gameObject) { isTouchingGround = true; break; } } }
void FixedUpdate() { if (!ManagerPause.Pause && !ManagerStop.Stop) { if (!useArea) { isCollide = Physics2D.OverlapCircleNonAlloc(objectCheck.position, objectRadius, result, whatIsCollide) > 0; } else { isCollide = Physics2D.OverlapAreaNonAlloc(new Vector2(pointA.x + objectCheck.position.x, pointA.y + objectCheck.position.y), new Vector2(pointB.x + objectCheck.position.x, pointB.y + objectCheck.position.y), result, whatIsCollide) > 0; } } }
void GroundCheck() { Bounds box = groundDetection.bounds; int numColliders = Physics2D.OverlapAreaNonAlloc(box.min, box.max, overlappingColliders); isTouchingGround = false; for (int i = 0; i < numColliders; i++) { if (overlappingColliders[i].gameObject != gameObject) { isTouchingGround = true; break; } } }
// Update is called once per frame void FixedUpdate() { m_Grounded = false; m_Walled = false; m_Climb = false; // The player is grounded if a circlecast to the groundcheck position hits anything designated as ground // This can be done using layers instead but Sample Assets will not overwrite your project settings. int max = Physics2D.OverlapCircleNonAlloc(m_GroundCheck.position, k_GroundedRadius, colliders, m_WhatIsGround); for (int i = 0; i < max; i++) { if (colliders[i].gameObject != gameObject) { m_Grounded = true; } } if (!m_Grounded) { max = Physics2D.OverlapAreaNonAlloc(m_WallCheck.position + Vector3.left * largeur + Vector3.up * hauteur, m_WallCheck.position + Vector3.right * largeur + Vector3.down * hauteur, colliders, m_WhatIsGround); for (int i = 0; i < max; i++) { if (colliders[i].gameObject != gameObject) { m_Walled = true; } } if (m_Walled) { m_Climb = true; max = Physics2D.OverlapAreaNonAlloc(m_WallCheck.position + Vector3.left * largeur * 4 + Vector3.up * (hauteur + hauteurClimb), m_WallCheck.position + Vector3.right * largeur * 4 + Vector3.up * hauteur, colliders, m_WhatIsGround); for (int i = 0; i < max; i++) { if (colliders[i].gameObject != gameObject) { m_Climb = false; } } } } m_Anim.SetBool("Ground", m_Grounded); //Set the vertical animation m_Anim.SetFloat("vSpeed", m_Rigidbody2D.velocity.y); }
void CollisionCheck() { // Translate GameObject point markers to Vector2 (probably very slow and inefficient but I couldn't figure it out yet) groundPointA = GgroundPointA.transform.position; groundPointB = GgroundPointB.transform.position; leftWallPointA = GleftWallPointA.transform.position; leftWallPointB = GleftWallPointB.transform.position; rightWallPointA = GrightWallPointA.transform.position; rightWallPointB = GrightWallPointB.transform.position; // Check if area created by point A to B (below character cube) overlaps with Layer Mask (level) and throws overlap results into overlaps array grounded = Physics2D.OverlapAreaNonAlloc(groundPointA, groundPointB, overlaps, layer); leftWallHang = Physics2D.OverlapAreaNonAlloc(leftWallPointA, leftWallPointB, overlaps, layer); rightWallHang = Physics2D.OverlapAreaNonAlloc(rightWallPointA, rightWallPointB, overlaps, layer); }
void UpdateLines() { if (!isServer) { return; } int lineZero = GameManager.singleton.lineZero; int colZero = GameManager.singleton.columnZero; Collider2D[] colliders = new Collider2D[20]; int walls; int layerID = LayerMask.NameToLayer("Tetroid"); // 0-31 int layerMask = 1 << layerID; int i = lineZero; while (i <= -lineZero) { walls = 0; walls = Physics2D.OverlapAreaNonAlloc(new Vector2(colZero, i - 0.25f), new Vector2(-colZero, i + 0.25f), colliders, layerMask); if (walls == (-colZero) * 2 + 1) // Line completed { GameManager.singleton.rowsCompleted++; GameManager.singleton.arkanoidY -= 1; frequency += 0.01f; Time.timeScale = frequency; for (int a = 0; a < walls; a++) { NetworkServer.Destroy(colliders[a].gameObject); } for (int j = i + 1; j <= -lineZero; j++) { walls = Physics2D.OverlapAreaNonAlloc(new Vector2(colZero, j - 0.25f), new Vector2(-colZero, j + 0.25f), colliders, layerMask); for (int a = 0; a < walls; a++) { colliders[a].transform.Translate(Vector2.down, Space.World); } } } else { i++; } } }
bool EnemyDetected(Vector2 originPosition) { //Check if the area around this (calculate by multiply by safety area pos) this random pos has any enemies Vector2 topLeft = new Vector2(originPosition.x - TileSize.x * safetyRadius, originPosition.y + TileSize.y * safetyRadius); Vector2 bottomRight = new Vector2(originPosition.x + TileSize.x * safetyRadius, originPosition.y - TileSize.y * safetyRadius); int n = Physics2D.OverlapAreaNonAlloc(topLeft, bottomRight, overlappedColliders, interactionLayer); if (n > 0) { for (int i = 0; i < n; i++) { if (overlappedColliders[i].CompareTag("Enemy")) { return(true); } } } return(false); }
public bool IsLedgeDetected(out Collider2D ledge) { if (_detectionBoxP2 == null || _detectionBoxP1 == null) { ledge = null; return(false); } var ledgeDetectorUpperBound = LedgeDetectorUpperBound; var freeSpaceLowerBound = FreeSpaceLowerBound; var count = Physics2D.OverlapAreaNonAlloc(_detectionBoxP1.transform.position, ledgeDetectorUpperBound, _resultBuffer, _whatIsGround); ledge = null; for (var idx = 0; idx < count; idx++) { var collider = _resultBuffer[idx]; if (!collider.isTrigger) { ledge = collider; break; } } if (ledge == null) { return(false); } count = Physics2D.OverlapAreaNonAlloc(freeSpaceLowerBound, _detectionBoxP2.transform.position, _resultBuffer, _whatIsGround); for (var idx = 0; idx < count; idx++) { var collider = _resultBuffer[idx]; if (!collider.isTrigger) { ledge = null; return(false); } } return(true); }
public HealthState CheckHit(Vector2 position) { var hitsCount = Physics2D.OverlapAreaNonAlloc(_lastPosition, position, _hitColliders); _lastPosition = position; if (hitsCount == 0) { return(null); } var enemyView = _hitColliders[0].GetComponent <IBulletTarget>(); if (enemyView == null) { return(null); } HitPosition = _hitColliders[0].transform.position; return(enemyView.HealthState); }
// ----------------------------------------------------------------------------------- /// <summary> /// Returns true if there is another play area object in the same position (requires collider) /// </summary> /// <returns></returns> public bool IsOverlapping() { if (collider == null) { throw new System.Exception("Cannot determine size without a collider"); } Bounds bounds = collider.bounds; int hits = Physics2D.OverlapAreaNonAlloc(bounds.min, bounds.max, overlaps, PlayArea.EnemiesLayerMask | PlayArea.BonusesLayerMask); bool result = false; for (int i = 0; i < hits && !result; i++) { // it only overlaps if it's not the same object AND if that object is not a child result = overlaps[i].gameObject != gameObject && !overlaps[i].transform.IsChildOf(transform); } return(result); }
private void FixedUpdate() { int requestsCount = pendingSplashRequests.Count; if (requestsCount > 0) { for (int i = 0; i < requestsCount; i++) { SplashRequest splashRequest = pendingSplashRequests[i]; int captured = Physics2D.OverlapAreaNonAlloc(splashRequest.center - splashRequest.size, splashRequest.center + splashRequest.size, splashables, enemyLayer); for (int j = 0; j < captured; j++) { if (splashables[j] != null) { splashables[j].GetComponent <EnemyDummy>().TakeDamage(splashRequest.damage); } } } pendingSplashRequests.Clear(); } }
protected void CheckPlayerHit(AttackState attack) { if (!_attackCollider || !_attackCollider.enabled) { return; } var pointA = _attackCollider.offset; pointA.x *= _movable.GetDirection(); pointA = (pointA + (Vector2)transform.position) - _attackCollider.size / 2f; var pointB = _attackCollider.offset; pointB.x *= _movable.GetDirection(); pointB = (pointB + (Vector2)transform.position) + _attackCollider.size / 2f; Collider2D[] colliders = new Collider2D[8]; if (Physics2D.OverlapAreaNonAlloc(pointA, pointB, colliders, (1 << _hitboxColliderLayer.value) | (1 << _attackColliderLayer.value)) <= 0) { return; } for (int i = 0; i < colliders.Length; i++) { var otherCollider = colliders[i]; if (otherCollider && LayerMask.LayerToName(otherCollider.gameObject.layer) == "HitboxCollider" && otherCollider.gameObject != gameObject) { var player = otherCollider.GetComponentInParent <Player>(); if (player && !_attackedPlayer) { _attackedPlayer = true; player.Damage(attack.damage); } } } }
void Update() { if (OnCharacterFound == null) { return; } var count = Physics2D .OverlapAreaNonAlloc( _finderAreaP1.position, _finderAreaP2.position, _colliderBuffer, _characterLayer); for (var idx = 0; idx < count; idx++) { var controller = _colliderBuffer[idx].GetComponent <BasePlatformerController>(); if (controller != null) { OnCharacterFound(controller); } } }
private void SpawnButton() { ButtonSpawnPosition.Set(Random.Range(spawnArea.xMin, spawnArea.xMax), Random.Range(spawnArea.yMin, spawnArea.yMax)); SetMinMaxSize(ButtonSpawnPosition); var attemptToFind = 20; while (Physics2D.OverlapAreaNonAlloc(min, max, resOfOverlapAreaNonAlloc) > 1 && attemptToFind > 0) { ButtonSpawnPosition.Set(Random.Range(spawnArea.xMin, spawnArea.xMax), Random.Range(spawnArea.yMin, spawnArea.yMax)); SetMinMaxSize(ButtonSpawnPosition); attemptToFind--; } if (Physics2D.OverlapAreaNonAlloc(min, max, resOfOverlapAreaNonAlloc) != 1) { return; } var btn = Instantiate(button, ButtonSpawnPosition, Quaternion.identity); btn.GameController = this; }
public List <Unit> GetAllUnitsOnScreen() { Camera cam = Camera.main; cameraBounds = cam.OrthographicBounds(); Vector2 pointA = cameraBounds.min; Vector2 pointB = cameraBounds.max; onScreenUnits.Clear(); unitsOnScreen = Physics2D.OverlapAreaNonAlloc(pointA, pointB, results); for (int i = 0; i < unitsOnScreen; i++) { Unit u = results[i].GetComponentInParent <Unit>(); if (u != null) { if (!onScreenUnits.Contains(u)) { onScreenUnits.Add(u); } } } return(onScreenUnits); }