public int BoxCastNonAlloc(Vector2 size, bool forward, LayerMask thingsToHit, float castDistance, ref RaycastHit2D[] hits) { Vector2 direction = Vector2.zero; direction.x = (forward) ? collisionInfo.faceDir : -collisionInfo.faceDir; return(Physics2D.BoxCastNonAlloc(transform.position, size, transform.eulerAngles.z, direction, hits, castDistance, thingsToHit)); }
private void Update() { if (!target) { return; } float vertical = Camera.main.orthographicSize; float horizontal = Camera.main.orthographicSize * Screen.width / Screen.height; Vector3 phantomPosition = target.position + offset; Vector3 differencePosition = phantomPosition - transform.position; for (int i = 0; i < Physics2D.BoxCastNonAlloc(transform.position, new Vector2(horizontal - 0.1f, vertical - 0.1f) * 2f, 0f, (phantomPosition - transform.position).normalized, hits, (phantomPosition - transform.position).magnitude + 0.1f, collisionLayerMask); i++) { if (hits[i].normal == Vector2.up || hits[i].normal == Vector2.down) { differencePosition.y = (hits[i].distance - 0.1f) * -hits[i].normal.x; } else if (hits[i].normal == Vector2.right || hits[i].normal == Vector2.left) { differencePosition.x = (hits[i].distance - 0.1f) * -hits[i].normal.y; } } transform.Translate(differencePosition); }
public int Square2DCast(Vector2 position, float side, RaycastHit2D[] buffer, int layerMask) { Vector2 direction = new Vector2(0, -1); // return(Physics2D.BoxCastNonAlloc(position, new Vector2(side, side), 0f, direction, buffer, Mathf.Infinity, layerMask)); }
bool CheckUpDown(float _yDirection, float _ySpeed) { bool impactCollision = false; Vector2 newVelocity = Vector2.zero; RaycastHit2D[] collisionResults = new RaycastHit2D[10]; Vector2 direction = new Vector2(0f, _yDirection); // General collision checks int colliderCount = Physics2D.BoxCastNonAlloc(new Vector2(transform.position.x, transform.position.y) + collider2D.offset, boxCollider2D.size, 0f, direction, collisionResults, _ySpeed, contactFilter.layerMask); Vector3 position = transform.position; Vector2 leftOverTravel = Vector2.zero; if (colliderCount > 0) { for (int colliderIndex = 0; colliderIndex < colliderCount; colliderIndex++) { RaycastHit2D hit = collisionResults[colliderIndex]; //Debug.Log (hit.collider.gameObject); if (!hit.collider.isTrigger && !Maths.EqualZero(hit.normal.y)) { float moveSign = Mathf.Sign(hit.normal.y); if (!Maths.EqualZero(_ySpeed) && (moveSign != Mathf.Sign(_ySpeed))) { velocity.y = 0; position.y = hit.point.y - (((boxCollider2D.size.y * 0.5f) + boxCollider2D.offset.y + colliderError) * -moveSign); impactCollision = true; } } } } return(impactCollision); }
void HandleWallCollision() { Vector2 direction = new Vector2(mDeltaVelocity.x > 0f ? 1f : -1f, 0f); RaycastHit2D[] collisionResults = new RaycastHit2D[5]; int collisionCount = Physics2D.BoxCastNonAlloc(mPosition, mPlayerSize, 0f, direction, collisionResults, Mathf.Abs(mDeltaVelocity.x), CollisionLayer); bool collisionHappened = false; if (collisionCount > 0) { for (int index = 0; index < collisionCount; index++) { float yDistance = collisionResults[index].point.y - mPosition.y; float xSign = collisionResults[index].point.x < mPosition.x ? -1f : 1f; if ((Mathf.Abs(yDistance) < (mHalfPlayerSize.y - 0.0001f)) && (xSign == direction.x)) { mWallDirection = (int)xSign; collisionHappened = mWallCollision = true; mDeltaVelocity.x = mVelocity.x = 0f; mPosition.x = MathFloat.Round(collisionResults[index].point.x - (mHalfPlayerSize.x * direction.x), 2); break; } } } if (!collisionHappened) { mWallCollision = false; } }
private bool SweepDirection(Transform origin, TileType direction) { Vector2 dir; switch (direction) { default: case TileType.None: return(false); case TileType.Up: dir = Vector2.up; break; case TileType.Left: dir = Vector2.left; break; case TileType.Right: dir = Vector2.right; break; case TileType.Down: dir = Vector2.down; break; } var hits = Physics2D.BoxCastNonAlloc(origin.position, Vector2.one / 2f, 0f, dir, new RaycastHit2D[2], 10f); return(hits > 1); }
public bool Punch() { if (!hasPunch) { return(false); } Vector2 direction = Vector2.right * controller.movementController.LastDirection; float lungeForce = controller.movementController.IsBlocked ? _punchLungeForce : _airPunchLunchForce; controller.movementController.AddForce(direction * lungeForce); int contacts = Physics2D.BoxCastNonAlloc(transform.position, Vector2.one * 0.75f, 0, direction, _hits, _punchDistance, enemyLayerMask); for (int i = 0; i < contacts; i++) { if (_hits[i].collider.gameObject.tag == "Enemy") { Vulnerable consumer = _hits[i].collider.gameObject.GetComponent <Vulnerable>(); if (consumer) { consumer.RecieveAttack(AttackType.Punch, attackCollider, _hits[i]); Debug.DrawLine(transform.position, consumer.transform.position, Color.red, 2.0f); return(true); } } } Debug.DrawLine(transform.position, transform.position + ((Vector3)direction * _punchDistance), Color.blue, 2.0f); return(true); }
//------------------------------------------------------------------------------------------ // 通り抜け処理 //------------------------------------------------------------------------------------------ protected void Pass() { // 下入力時に通り抜けるようにする if (Input.GetAxis(Player.VERTICAL) < -passSensitivity) { passable = true; platform.colliderMask &= ~passLayerMask.value; } // 通り抜け中か判定する if (passable) { int hitCount = Physics2D.BoxCastNonAlloc(thisCollider.bounds.center, thisCollider.bounds.size, 0, Vector2.down, results, 0, passLayerMask.value); for (int i = 0; i < hitCount; i++) { if (results[i].collider.isTrigger && results[i].collider.tag == "Player") { continue; } platform.colliderMask &= ~passLayerMask.value; return; } passable = false; } else { platform.colliderMask |= passLayerMask.value; } }
public override bool getBranch() { GameObject[] projectiles = GameObject.FindGameObjectsWithTag("Projectile"); foreach (GameObject projectile in projectiles) { Rigidbody2D rb = projectile.GetComponent <Rigidbody2D>(); BoxCollider2D bc = projectile.GetComponent <BoxCollider2D>(); RaycastHit2D[] results = new RaycastHit2D[50]; int numHits = Physics2D.BoxCastNonAlloc( projectile.transform.position, bc.size, 0, rb.velocity, results ); foreach (var result in results) { if (character != null && result.collider != null && result.collider.gameObject != null) { if (result.collider.gameObject.name == character.name) { Vector2 perpendicular = Vector2.Perpendicular(rb.velocity); Vector3 perp3 = perpendicular; character.GetComponent <AIMovementScript>().avoidProjectileAction.targetPosition = character.transform.position + (perp3 * 5); return(true); } } } } return(false); }
public bool GetFirstBoxcastHit(Vector2 direction, float maxDist, LayerMask targetLayers, out RaycastHit2D location) { InitializeResults(); int hits = Physics2D.BoxCastNonAlloc(transform.position, _boxCastSize, 0, direction, _raycastResults, maxDist, targetLayers.value); if (hits > 0) { for (int i = 0; i < hits; i++) { if (_raycastResults[i].transform != this.transform) { location = _raycastResults[i]; return(true); } } location = new RaycastHit2D(); return(false); } else { location = new RaycastHit2D(); return(false); } }
void AirbotHit() { hitCount = Physics2D.BoxCastNonAlloc(transform.position, box.size, 0, velocity, RaycastHits, raylength, Global.CharacterDamageLayers); for (int i = 0; i < hitCount; i++) { hit = RaycastHits[i]; IDamage dam = hit.transform.GetComponent <IDamage>(); if (dam != null) { Damage dmg = Instantiate(ContactDamage); dmg.instigator = this; dmg.damageSource = transform; dmg.point = hit.point; if (dam.TakeDamage(dmg)) { hitpause = true; pathAgent.SetPath(new Vector3(hit.point.x, hit.point.y, 0) + Vector3.up * hitPauseOffset); animator.Play("laugh"); hitPauseTimer.Start(1, null, delegate { hitpause = false; animator.Play("idle"); }); } } } }
public void Fire() { RaycastHit2D[] results = new RaycastHit2D[64]; Physics2D.queriesHitTriggers = false; var amount = Physics2D.BoxCastNonAlloc(transform.position, new Vector2(1f, Width), 0f, Hero.FacingRight ? Vector2.right : Vector2.left, results, Range); for (var i = 0; i < amount; ++i) { var result = results[i]; NotifyDamage(results[i].collider.gameObject); } Physics2D.queriesHitTriggers = true; if (Clip) { AudioSource.PlayClipAtPoint(Clip, transform.position); } if (LaserObject) { var newLaserObject = Instantiate(LaserObject); newLaserObject.transform.position = transform.position; Destroy(newLaserObject, 0.25f); } Destroy(this); }
private (bool, float) CastQuad(Vector2 position, Vector2 direction, float distance) { float castAngle = 0; bool stuck = false; int count = Physics2D.BoxCastNonAlloc(position, quadCastSize, castAngle, direction, hits, distance, layerMask); float minDistance = distance; for (int i = 0; i < count; i++) { RaycastHit2D hit = hits[i]; if (!hit || hit.transform == transform) { continue; } float hitDistance = hit.distance; if (hitDistance > 0) { stuck = true; if (minDistance > hitDistance) { minDistance = hitDistance; } } } return(stuck, minDistance); }
bool HandleWallCollision(out RaycastHit2D _collisionResult) { bool collided = false; Vector2 midWalkPoint = new Vector2(mPosition.x + (mDeltaVelocity.x / 2f), mPosition.y); Vector2 boxSize = new Vector2(Mathf.Abs(mDeltaVelocity.x) + mObjectSize.x, mObjectSize.y); Vector2 direction = new Vector2(mDeltaVelocity.x > 0f ? 1f : -1f, 0f); // Array of objects that would be collided with RaycastHit2D[] collisionResults = new RaycastHit2D[5]; int collisionCount = Physics2D.BoxCastNonAlloc(mPosition, mObjectSize, 0f, direction, collisionResults, mDeltaVelocity.x, CollisionLayer); for (int index = 0; index < collisionCount; index++) { float yDistance = collisionResults[index].point.y - mPosition.y; float xSign = collisionResults[index].point.x < mPosition.x ? -1 : 1; // Does the object actually matter if ((Mathf.Abs(yDistance) < (mHalfObjectSize.y - 0.0001f)) && (xSign == direction.x)) { // Quit moving and set yourself as close to the wall as possible mDeltaVelocity.x = mVelocity.x = 0f; mPosition.x = collisionResults[index].point.x - (mHalfObjectSize.x * direction.x); _collisionResult = collisionResults[index]; collided = true; break; } } _collisionResult = new RaycastHit2D(); return(collided); }
public void BoxCast( Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = Physics2D.DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity) { Count = Physics2D.BoxCastNonAlloc(origin, size, angle, direction, Results, distance, layerMask, minDepth, maxDepth); }
bool MustTurn() { var hits = Physics2D.BoxCastNonAlloc(WallTest.transform.position, new Vector2(.1f, .1f), 0f, Vector2.zero, dummy, 0f, mask); if (hits > 0) { return(true); } hits = Physics2D.BoxCastNonAlloc(GroundTest.transform.position, new Vector2(.1f, .1f), 0f, Vector2.zero, dummy, 0f, mask); return(hits == 0); }
/// <summary> /// 碰撞检测 /// </summary> /// <param name="dir"></param> /// <param name="distance"></param> /// <returns></returns> public override RaycastHit2D[] GetCurrentCast(Vector2 dir, float distance) { if (!enabled) { m_len = 0; return(m_results); } Vector3 pos = m_trans.position + new Vector3(rect.center.x, rect.center.y, rect.center.z); m_len = Physics2D.BoxCastNonAlloc(pos, rect.size, 0, dir, m_results, distance, checkLayer); return(m_results); }
public bool CheckMove(Vector3 pos) { Physics2D.BoxCastNonAlloc(pos, size, 0, new Vector2(0, 0), results, 0, layerMask); if (results[0].collider != null) { result = results[0]; results = new RaycastHit2D[1]; return(false); } return(true); }
void MechHit() { if (ContactDamage == null) { return; } // body hit hitCount = Physics2D.BoxCastNonAlloc(body.position, box.size, 0, velocity, RaycastHits, raylength, Global.CharacterDamageLayers); for (int i = 0; i < hitCount; i++) { hit = RaycastHits[i]; IDamage dam = hit.transform.GetComponent <IDamage>(); if (dam != null) { Damage dmg = Instantiate(ContactDamage); dmg.instigator = this; dmg.damageSource = transform; dmg.point = hit.point; dam.TakeDamage(dmg); } } hitCount = Physics2D.BoxCastNonAlloc(torso.transform.position, torso.size, 0, velocity, RaycastHits, raylength, Global.CharacterDamageLayers); for (int i = 0; i < hitCount; i++) { hit = RaycastHits[i]; IDamage dam = hit.transform.GetComponent <IDamage>(); if (dam != null) { Damage dmg = Instantiate(ContactDamage); dmg.instigator = this; dmg.damageSource = transform; dmg.point = hit.point; dam.TakeDamage(dmg); } } // fist hit hitCount = Physics2D.BoxCastNonAlloc(fist.transform.position, fist.size, 0, Vector2.zero, RaycastHits, raylength, Global.CharacterDamageLayers); for (int i = 0; i < hitCount; i++) { hit = RaycastHits[i]; IDamage dam = hit.transform.GetComponent <IDamage>(); if (dam != null) { Damage dmg = Instantiate(ContactDamage); dmg.instigator = this; dmg.damageSource = transform; dmg.point = hit.point; dam.TakeDamage(dmg); } } }
//------------------------------------- private bool GroundedCheck() { if (Physics2D.BoxCastNonAlloc(rigidbody2D.position + Vector2.right * thisBoxCollider2D.center.x * thisTransform.localScale.x + Vector2.up * thisBoxCollider2D.center.y, thisBoxCollider2D.size, 0f, -Vector2.up, groundCastHit, groundedCheckDistance) > 0) { if (Vector2.Dot(Vector2.up, groundCastHit[0].normal) >= maxSlopeDotProduct) { return(true); } } return(false); }
void getElements() { TriggerElement.Clear(); int mask = 1 << 16; Physics2D.BoxCastNonAlloc(BoxColl.bounds.center, GameFunction.getVector3(BoxColl.size.x * Mathf.Abs(transform.lossyScale.x), BoxColl.size.y * Mathf.Abs(transform.lossyScale.y), 1), transform.rotation.eulerAngles.z, Vector2.zero, hitPoints, 0, mask); for (int i = 0; hitPoints[i].transform != null; i++) { if (hitPoints[i].collider != BoxColl) //排除自己 { TriggerElement.Add(hitPoints[i].collider.GetComponent <Element>().element); } } }
void Update() { int hits = Physics2D.BoxCastNonAlloc(box.bounds.center, box.bounds.extents, 0f, Vector2.up, scan, 0.1f, 1 << LayerMask.NameToLayer("ResourcePile")); if (hits > 0) { for (int i = 0; i < hits; i++) { ResourcePile resPile = scan[i].collider.gameObject.GetComponent <ResourcePile>(); resPile.ClearVisuals(); } UpdateGUI(); } }
protected void RCXY_noAl(Vector2 direction, float distance, Vector2 center, Vector2 size, LayerMask layerMask) { float angle = Vector2.Angle(velocity, Vector2.right * Mathf.Sign(velocity.x)); skinDistance = skin; float cos = Mathf.Cos(angle * Mathf.Deg2Rad); if (cos > skin) { skinDistance = skin / cos; } Physics2D.BoxCastNonAlloc(center, size, 0, direction, platforms, distance + skinDistance, layerMask); }
private void applyMovement() { // Stick to surface int contacts = Physics2D.BoxCastNonAlloc(transform.position, Vector2.one * castColliderSize, 0, _up * -1, _hits, movementSettings.surfacePull, movementSettings.surfaceLayerMask); float maxMoveDistance = movementSettings.surfacePull; for (int i = 0; i < contacts; i++) { if (_hits[i].collider != collider) { maxMoveDistance = _hits[i].distance; break; } } float moveDistance = Mathf.Clamp(maxMoveDistance, 0, movementSettings.surfacePull * Time.deltaTime); Vector2 moveDirection = _up * -1; if (moveDistance >= movementSettings.minWallDistance) { transform.position += (Vector3)moveDirection * (moveDistance - movementSettings.minWallDistance * 0.9f); _isOnWall = false; } else { _isOnWall = true; } if (_isOnWall) { // Slide along surface float absVelocity = Mathf.Abs(_velocity); moveDirection = _velocity > 0 ? _right : _right * -1f; contacts = Physics2D.BoxCastNonAlloc(transform.position, Vector2.one * castColliderSize, 0, moveDirection, _hits, absVelocity, movementSettings.surfaceLayerMask); maxMoveDistance = absVelocity; for (int i = 0; i < contacts; i++) { if (_hits[i].collider != collider) { maxMoveDistance = _hits[i].distance; break; } } _isBlocked = (maxMoveDistance < absVelocity); moveDistance = Mathf.Clamp(maxMoveDistance, 0, absVelocity); transform.position += (Vector3)moveDirection * Time.deltaTime * moveDistance; } }
public bool PickBlockUp() { RaycastHit2D[] hits = new RaycastHit2D[1]; bool facingLeft = _motor.facingLeft; Physics2D.BoxCastNonAlloc( _collider2D.bounds.center, _collider2D.bounds.size, 0f, (facingLeft ? Vector2.left : Vector2.right), hits, 0.2f, blockLayer); if (hits[0].collider != null) { _holdingBlock = hits[0].collider.gameObject; Block block = _holdingBlock.GetComponent <Block>(); Vector3 position = _holdingBlock.transform.position; if ((block.IsOnOther && transform.position.y + 0.1f < position.y) || block.IsOtherOnIt || block.State == Block.BlockState.Holding) { return(false); } position.x = transform.position.x + (facingLeft ? -0.75f : 0.75f) * (1 + carryingBlockOffset.x); position.y = transform.position.y + carryingBlockOffset.y; _holdingBlock.transform.position = position; _holdingBlock.transform.parent = transform; block.State = Block.BlockState.Holding; Vector2 offset = _collider2D.offset; Vector2 size = _collider2D.size; offset.x = (facingLeft ? -0.5f : 0.5f); size.x = 1.5f; _collider2D.offset = offset; _collider2D.size = size; _isHoldingBlock = true; return(true); } return(false); }
public void MakeDash() { var position = (Vector2)transform.position; var destination = position; var facing = characterController.FacingRight ? 1 : -1; destination.x += distance * facing; var boxSize = _collider.bounds.size; boxSize.x *= 0.2f; boxSize.y *= 0.8f; var size = Physics2D.BoxCastNonAlloc(position, boxSize, 0f, destination - position, _hits, distance, collisionMask); IterateThroughColliders(position, destination, size); }
private IEnumerator Start() { while (true) { var hits = Physics2D.BoxCastNonAlloc(_bounceBoxCastPosition, _bounceBoxCastSize, 0, Vector2.zero, _groundedFruits, 0, FruitController.layerMask); for (var i = 0; i < hits; i += 1) { _groundedFruits[i].collider.gameObject.GetComponent <Rigidbody2D>() .AddForce(Vector2.up * BOUNCE_FORCE, ForceMode2D.Impulse); } yield return(StartCoroutine(AnimateTruck())); yield return(new WaitForSeconds(Random.Range(1, 5))); } }
void AttackCast() { if (_isAttackState) { Vector3 pos = _node.MeleeAttackPos.transform.position; pos.x = _forward.x < 0 ? pos.x - CallAttackOffset() : pos.x; int count = Physics2D.BoxCastNonAlloc(pos, _node.MeleeCheckRectSize, 0, _forward, _attackHitBuffer, 0.3f, _unitLayerMask); _hitBufferList.Clear(); for (int i = 0; i < count; i++) { _hitBufferList.Add(_attackHitBuffer[i]); } if (_hitBufferList.Count > 0 && AttackColliderList != null) { AttackColliderList(_hitBufferList); } } }
void FixedUpdate() { if (!isServer) { return; } float moveForce = settings.moveSpeed * Time.fixedDeltaTime; int hitCount = Physics2D.BoxCastNonAlloc(ownTransform.position, settings.ballSize, 0f, moveDirection, raycastResults, moveForce, raycastLayer); if (hitCount > 0) { collisionHandler.SolveCollision(HitResult, ref moveDirection, ref moveForce); } moveHandler.MovePosition(this, moveDirection * moveForce); Debug.DrawRay(ownTransform.position, moveDirection, Color.red); }
protected void BoxCollisionOneDown() { collideRight = false; collideLeft = false; collideTop = false; collideBottom = false; const float corner = 0.707f; boxOffset.x = box.offset.x * Mathf.Sign(transform.localScale.x); boxOffset.y = box.offset.y; adjust = (Vector2)transform.position + boxOffset; hitCount = Physics2D.BoxCastNonAlloc(adjust, box.size, 0, Vector2.down, RaycastHits, Mathf.Max(raylength, -velocity.y * Time.deltaTime), Global.CharacterCollideLayers); for (int i = 0; i < hitCount; i++) { hit = RaycastHits[i]; if (hit.normal.y > corner) { if (IgnoreCollideObjects.Count > 0 && IgnoreCollideObjects.Contains(hit.collider)) { continue; } collideBottom = true; adjust.y = hit.point.y + box.size.y * 0.5f + contactSeparation; // moving platforms Entity cha = hit.transform.GetComponent <Entity>(); if (cha != null) { #if UNITY_EDITOR if (cha.GetInstanceID() == GetInstanceID()) { Debug.LogError("character set itself as carry character", gameObject); Debug.Break(); } #endif carryCharacter = cha; } break; } } transform.position = adjust - boxOffset; }