public bool _Move(int xDir, int yDir) { Vector2 start = transform.position; Vector2 end = start + new Vector2(xDir * movingdistance, yDir * movingdistance); //boxCollider.enabled = false; //x方向は少し下にRayを飛ばす Vector2 v = new Vector2(0, 0.1f); //自分と同一のレイヤーとEncountArea以外のすべてを判定する LayerMask mask = ~(1 << gameObject.layer | 1 << LayerMask.NameToLayer("EncountArea")); RaycastHit2D[] hits = new RaycastHit2D[3]; BoxCollider2D[] result = new BoxCollider2D[3]; //var hitNum = Physics2D.LinecastNonAlloc(start - v, end - v, hits, mask); Vector2 size = new Vector2(0.9f, 0.5f); Vector2 size0 = new Vector2(0.9f, 0.9f); //var hitNum = Physics2D.BoxCastNonAlloc(start, size, 0, direction, hits, 0.5f, mask); var hitNum = Physics2D.OverlapBoxNonAlloc(gameObject.transform.position + ((Vector3)direction * 0.5f), size0, 0, result, mask); Debug.DrawLine(start - v, end - v, Color.blue, 1f); //boxCollider.enabled = true; foreach (var hit in result) { //Debug.Log(hit.transform.gameObject.name); if (hit?.isTrigger == false) { return(false); } } smoothMovement = StartCoroutine(SmoothMovement(end)); return(true); }
private void CheckForCloudCollision() { Array.Clear(hitColliders, 0, hitColliders.Length); // Unfortunately, the bounds don't seem to respect scale, so we have to manually calculate the correct box size var boxSize = Vector3.Scale(text.bounds.size, transform.lossyScale); var numHits = Physics2D.OverlapBoxNonAlloc(transform.position, boxSize, 0f, hitColliders, (int)LayerMasks.Cloud); if (numHits > 0) { foreach (var collider in hitColliders) { if (collider != null) { if (collider.CompareTag(Tags.Enemy)) { var cloud = collider.GetComponent <Cloud>(); if (cloud != null) { cloud.OnAlphabetImpact(CurrentChar); IsActive = false; } } else { // TODO: Bad things happen. Filter out the stuff to collide with first using layer masks before implementing this } } } } }
IEnumerator DoBlockUpdate() { yield return(null); Vector2 pos = transform.position + bounds.center; //grab blocks int collCount = Physics2D.OverlapBoxNonAlloc(pos, bounds.size, 0f, mColls, blockLayerMask); for (int i = 0; i < collCount; i++) { var b = mColls[i].GetComponent <Block>(); if (b) { int ind = GetIDData(b); if (ind != -1) { mAttachedBlocks.Add(b); ids[ind].ApplyColor(); BlockConnectController.instance.SetConnect(b.blockName, true); } } } }
void _Collision_Handler() { TotalFound = Physics2D.OverlapBoxNonAlloc(transform.position + offset, size, 0.0f, results, layerMask); if (IsFound) { if (!isEntered) { isEntered = true; for (uint i = 0; i < TotalFound; ++i) { _FireEvent_OnEnter(results[0].gameObject); } } _FireEvent_OnStay(results[0].gameObject); } else { if (isEntered) { isEntered = false; _FireEvent_OnExit(results[0].gameObject); } } }
private T GetClosest <T>(Collider2D[] buffer, LayerMask layerMask) { int count = Physics2D.OverlapBoxNonAlloc(InteractiveArea.transform.position, InteractiveArea.size, 360, buffer, layerMask); ClosestObject <T> closest = new ClosestObject <T> { angle = 360 }; for (int i = 0; i < count; ++i) { if (InteractablesBuffer[i] == null) { continue; } Transform found = InteractablesBuffer[i].transform; Vector3 facingdir = movement.GetFacing(); float angle = Vector2.Angle(facingdir, (found.position - transform.position).normalized); if (angle > 45f || angle > closest.angle) { continue; } closest.angle = angle; closest.obj = found.GetComponent <T>(); } return(closest.obj); }
private Dictionary <Rigidbody2D, Collider2D> GetRigidbodiesInHitCollider() { Vector2 center = hitCollider.transform.TransformPoint(hitCollider.offset); int count = Physics2D.OverlapBoxNonAlloc(center, hitCollider.size, 0f, colliderCache); rigidbodyCache.Clear(); for (int i = 0; i < count; i++) { Collider2D collider = colliderCache[i]; Rigidbody2D rigidbody = collider.attachedRigidbody; if (rigidbody == null) { continue; } if (rigidbody == Character.Rigidbody) { continue; } if (rigidbodyCache.ContainsKey(rigidbody)) { continue; } rigidbodyCache.Add(rigidbody, collider); } return(rigidbodyCache); }
/// <summary> /// Returns an array of components of type T at box with centerPoint, size, and angle. The numberOfCollidersToTest for is passed as a parameter. /// Found components are returned in the array. This method returns them in an array so there is less overhead if we're using it often /// </summary> public static T[] GetComponentsAtBoxLocationNonAlloc <T>(int numberOfCollidersToTest, Vector2 point, Vector2 size, float angle) { // This method has a generic type T, so it can be used for any type T that you pass in (say, T = Item) // Create a new Collider2D array, that will be used to be populated with the next method Collider2D[] collider2DArray = new Collider2D[numberOfCollidersToTest]; // This method will return all colliders that overlap with the given box area. This is memory efficient (doesn't allocate it's own memory at it goes), // and doesn't start garbage collection as frequently so it'll have less overhead, especially because we'll use it a lot Physics2D.OverlapBoxNonAlloc(point, size, angle, collider2DArray); // This is just the default type T T tComponent = default(T); // Array to store the found objects of type T in T[] componentArray = new T[collider2DArray.Length]; // Loop through all of the colliders to get objects of type T for (int i = collider2DArray.Length - 1; i >= 0; i--) { if (collider2DArray[i] != null) { tComponent = collider2DArray[i].gameObject.GetComponent <T>(); //Check if the found component of type T was found or not, if so, add it to our outpit array if (tComponent != null) { componentArray[i] = tComponent; } } } return(componentArray); }
//Returns array of components of type T at box with contre point and size and angle. the numberOfCollidersToTest for is passed as a parameter.Found //components are returned in the array. public static T[] GetComponentsAtBoxLocationNonAlloc <T>(int numberOfCollidersToTest, Vector2 point, Vector2 size, float angle) { Collider2D[] collider2DArray = new Collider2D[numberOfCollidersToTest]; Physics2D.OverlapBoxNonAlloc(point, size, angle, collider2DArray); T tComponent = default(T); T[] componentArray = new T[collider2DArray.Length]; for (int i = collider2DArray.Length - 1; i >= 0; i--) { if (collider2DArray[i] != null) { tComponent = collider2DArray[i].gameObject.GetComponent <T>(); if (tComponent != null) { componentArray[i] = tComponent; } } } return(componentArray); }
private void FixedUpdate() { if (Playing) { Physics2D.OverlapBoxNonAlloc((Vector2)transform.position + Vector2.up * 0.625f, new Vector2(0.99f, 0.25f), 0f, _overlapResults); for (int i = 0; i < _overlapResults.Length; i++) { var collider = _overlapResults[i]; _overlapResults[i] = null; if (!collider || collider.attachedRigidbody.bodyType == RigidbodyType2D.Static) { continue; } collider.attachedRigidbody.velocity = Vector2.zero; if (collider.attachedRigidbody.bodyType != RigidbodyType2D.Static) { collider.attachedRigidbody.MovePosition(collider.attachedRigidbody.position + (Vector2.right * _direction + Vector2.down * collider.attachedRigidbody.gravityScale) * Time.fixedDeltaTime); } } } }
protected virtual void HitDetection() { Collider2D[] cols = new Collider2D[1]; Physics2D.OverlapBoxNonAlloc(transform.position, Vector2.one * hitBoxSize, 0, cols, collisionLayers); if (cols[0]) { Instantiate(impactEffect, transform.position, Quaternion.identity); if (cols[0].GetComponent <EnemyHealth>()) { cols[0].GetComponent <EnemyHealth>().TakeDamage(); } Destroy(gameObject); } if (transform.position.x > cam.ScreenToWorldPoint(new Vector3(Screen.width, 0)).x) { Destroy(gameObject); } else if (transform.position.x < cam.ScreenToWorldPoint(new Vector3(0, 0)).x) { Destroy(gameObject); } else if (transform.position.y > cam.ScreenToWorldPoint(new Vector3(0, Screen.height)).y) { Destroy(gameObject); } else if (transform.position.y < cam.ScreenToWorldPoint(new Vector3(0, 0)).y) { Destroy(gameObject); } }
void FixedUpdate() { hitCount = Physics2D.OverlapBoxNonAlloc(hitOrigin.position, size, 0.0f, hits, actorMask); isBossInAttackRange = (hitCount > 0 && hits[0].CompareTag("Boss")); _Movement_Handler(); }
/// <summary> /// Get the components of the specified type within the box area /// </summary> /// <typeparam name="T"></typeparam> /// <param name="numberOfCollidersToTest"></param> /// <param name="point"></param> /// <param name="size"></param> /// <param name="angle"></param> /// <returns></returns> public static T[] GetComponentsAtBoxLocationNonAlloc <T>(int numberOfCollidersToTest, Vector2 point, Vector2 size, float angle) { Collider2D[] collider2DArray = new Collider2D[numberOfCollidersToTest]; // Store all colliders within the box area in the collider2DArray Physics2D.OverlapBoxNonAlloc(point, size, angle, collider2DArray); T tComponent = default(T); T[] componentArray = new T[collider2DArray.Length]; // Loop through the found colliders for (int i = collider2DArray.Length - 1; i >= 0; i--) { if (collider2DArray[i] != null) { // Get the component of the type from the game object tComponent = collider2DArray[i].gameObject.GetComponent <T>(); // Check if such a component exists if (tComponent != null) { // If so, add it to the componentArray componentArray[i] = tComponent; } } } return(componentArray); }
public Collider2D[] DetectCollidersNonAlloc(Transform _trans = null, int _maxAmount = 1) { SetCurDetectPos(_trans); cols = new Collider2D[_maxAmount]; if (detectType == DetectAreaType.Circle) { Physics2D.OverlapCircleNonAlloc(curDetectPos, radius, cols, detectMask); } else if (detectType == DetectAreaType.Box) { Physics2D.OverlapBoxNonAlloc(curDetectPos, size, angle, cols, detectMask); } else if (detectType == DetectAreaType.Point) { Physics2D.OverlapPointNonAlloc(curDetectPos, cols, detectMask); } else if (detectType == DetectAreaType.LineCast) { var hits = new RaycastHit2D[_maxAmount]; Physics2D.LinecastNonAlloc(curDetectPos, lastDetectPos, hits, detectMask); if (hits.Length > 0) { for (int i = 0; i < hits.Length; i++) { cols[i] = hits[i].collider; } } GetDirection(); } return(cols); }
public void StartPunch() { Vector2 playerPos2D = new Vector2(transform.position.x, transform.position.y); mask = 1 << LayerMask.NameToLayer("NPC"); mask |= 1 << LayerMask.NameToLayer("PromotionGuy"); float angle = Vector2.Angle(playerPos2D, playerPos2D + lookVector); int npcCount = Physics2D.OverlapBoxNonAlloc(playerPos2D + new Vector2(lookVector.x, lookVector.y) * punchHitBoxOffset, Vector2.one * punchHitBoxSize, angle, punchedNPCs, mask); if (npcCount > 0) { for (int i = 0; i < npcCount; i++) { if (punchedNPCs[i].TryGetComponent(out NPC npc)) { npc.OnStartPunch(); _punchedNPCs.Add(npc); } } } if (_punchComboCounter < 2) { ServiceLocator.Current.Get <AudioManager>().PlayLightPunchSFX(); } else { ServiceLocator.Current.Get <AudioManager>().PlayHardPunchSFX(); } _punchComboCounter++; }
public override void CheckOverlap() { if (!m_arrCondition.PassAllCondition(eventConditionData)) { return; } Vector2 vPos = m_hOverlapPosition != null ? m_hOverlapPosition.position : transform.position; float fAngle; if (m_bUseLocalAngle) { fAngle = m_hOverlapPosition != null ? m_hOverlapPosition.localEulerAngles.z : transform.localEulerAngles.z; } else { fAngle = m_hOverlapPosition != null ? m_hOverlapPosition.eulerAngles.z : transform.eulerAngles.z; } int nHit = Physics2D.OverlapBoxNonAlloc(vPos, m_vSize, fAngle, hitColArray, m_eCheckLayer); if (nHit <= 0) { m_hNotHitEvent?.Invoke(); return; } bool bHit = false; int nSendCount = 0; for (int i = 0; i < nHit; i++) { var hHitGO = m_arrHitCol[i].gameObject; if (CheckNotIgnoreTarget(hHitGO)) { if (!bHit) { m_hHitEvent?.Invoke(); } bHit = true; m_hHitEventGameObject?.Invoke(hHitGO); nSendCount++; if (nSendCount >= m_nMaxSendData) { break; } } } if (!bHit) { m_hNotHitEvent?.Invoke(); } }
protected override void HitDetection() { CheckOutOfScreen(); Collider2D[] cols = new Collider2D[1]; Physics2D.OverlapBoxNonAlloc(transform.position, Vector2.one * hitBoxSize, 0, cols, collisionLayers); if (cols[0]) { if (cols[0].GetComponent <PlayerHealth>()) { cols[0].GetComponent <PlayerHealth>().TakeDamage(); } Destroy(gameObject); } if (transform.position.x > cam.ScreenToWorldPoint(new Vector3(Screen.width, 0)).x + 1) { Destroy(gameObject); } else if (transform.position.x < cam.ScreenToWorldPoint(new Vector3(0, 0)).x - 1) { Destroy(gameObject); } else if (transform.position.y > cam.ScreenToWorldPoint(new Vector3(0, Screen.height)).y + 1) { Destroy(gameObject); } else if (transform.position.y < cam.ScreenToWorldPoint(new Vector3(0, 0)).y - 1) { Destroy(gameObject); } }
public override void Tick() //Fixed Tick { base.Tick(); if (!isRun) { return; } var nbCollider = Physics2D.OverlapBoxNonAlloc(TargetGo.transform.localPosition, size, 0f, colliderBuffer); isCollide = nbCollider > 1; if (isCollide) { if (lastCollision == null) { //- Hit Enter lastCollision = colliderBuffer[1].gameObject; FireHitEnter(lastCollision); return; } //- Hit Stay FireHitStay(colliderBuffer[1].gameObject); } else if (lastCollision != null) { //- Hit Exit FireHitExit(lastCollision); lastCollision = null; } else { lastCollision = null; } }
/// <summary> /// <para> /// Checks for a ground by using raycasts. /// </para> /// <br>A raycast does not ignore the collider if it is fired inside one. So to detect a ground,</br> /// <br>method checks the amount of hits there are and decides wether the character is touching ground or not.</br> /// </summary> /// <returns></returns> /// private bool IsGrounded() { groundDetectionCheckPosition = collisionBox.bounds.center; groundDetectionCheckPosition.y -= collisionBox.bounds.extents.y; //RaycastHit2D[] c = new RaycastHit2D[20]; Collider2D[] collider2 = new Collider2D[20]; //int hitCount = Physics2D.RaycastNonAlloc(collisionBox.bounds.center, Vector2.down, c, collisionBox.bounds.extents.y+0.03f); int hitCount = Physics2D.OverlapBoxNonAlloc(groundDetectionCheckPosition, groundCheckBoxSize, 0f, collider2); for (int i = 0; i < hitCount; i++) { if (hitCount >= 2) { isGrounded = true; //If there are two, its either player + one more object or 2 objects. Either case means there is ground } else if (hitCount == 1) { isGrounded = !collider2[0].transform.Equals(gameObject.transform); //If the collided transform does not belong to the player, then we are touching a ground } else { isGrounded = false; } } return(isGrounded); }
void FixedUpdate() //updates at physics speed { //limit rotation to -8 / 8 degrees Vector3 euler = transform.eulerAngles; if (euler.z > 180) { euler.z = euler.z - 360; } euler.z = Mathf.Clamp(euler.z, -8, 8); transform.eulerAngles = euler; isOnGround[0] = null; Physics2D.OverlapBoxNonAlloc(groundPos.position, new Vector2(boxLength, boxHeight), 0, isOnGround, groundLayer); if (isOnGround[0] && !flying) { body.velocity = new Vector2(moveInput * move_speed, body.velocity.y); body.freezeRotation = true; body.rotation = 0; } else if (flying) { Vector3 rotation = new Vector3(0, 0, -moveInput * rotationSpeed); transform.Rotate(rotation); body.freezeRotation = false; //Debug.Log("Force"); body.AddForce(transform.rotation * Vector2.up * jetPackForce); transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.identity, Time.deltaTime * rorateBackSpeed); } }
/** * Tries to find a position in a grid cell close to the given position which is free of colliders. * If none can be found, returns the given position. * * FIXME: Actually do an exhaustive search, currently, this just checks four neighboring cells */ public static Vector3 NearestFreeGridPosition(this Tilemap tilemap, Vector3 position) { var centerCell = tilemap.layoutGrid.WorldToCell(position); var toCheck = new[] { centerCell, centerCell + Vector3Int.up, centerCell + Vector3Int.left, centerCell + Vector3Int.right, centerCell + Vector3Int.down, centerCell + Vector3Int.up + Vector3Int.left, centerCell + Vector3Int.left + Vector3Int.down, centerCell + Vector3Int.right + Vector3Int.up, centerCell + Vector3Int.down + Vector3Int.right, }; var colliderBuffer = new Collider2D[1]; foreach (var cell in toCheck) { var worldPos = tilemap.GetCellCenterWorld(cell); if ( //Physics2D.OverlapCircleNonAlloc(worldPos, Mathf.Max(tilemap.cellSize.x, tilemap.cellSize.y), colliderBuffer) == 0 Physics2D.OverlapBoxNonAlloc(worldPos, tilemap.cellSize * 0.95f, 0, colliderBuffer) == 0 ) { return(new Vector3(worldPos.x, worldPos.y, position.z)); } } return(position); }
public static int overlapAllBox(BoxCollider2D collider, Collider2D[] results, int layer = -1) { Transform transform = collider.transform; Vector2 colliderWorldPos = localToWorld(transform, collider.offset); int hitCount = Physics2D.OverlapBoxNonAlloc(colliderWorldPos, collider.size, transform.localEulerAngles.z, results, layer); return(removeClassElement(results, hitCount, collider)); }
private bool HasTouchedGround() { LayerMask currentLayer = GetCurrentLayer(); int groundHits = Physics2D.OverlapBoxNonAlloc(groundCheck.position, groundCheck.lossyScale , groundCheck.eulerAngles.z, overlapResults, currentLayer); return(groundHits > 0); }
private void GroundCheck() { var position = transform.position; var result = Physics2D.OverlapBoxNonAlloc( new Vector2(position.x + groundColliderOffset.x, position.y + groundColliderOffset.y), groundColliderSize, 0f, _groundHit, whatIsGround); _isGrounded = result == 1; }
private bool HasTouchedRoof() { LayerMask currentLayer = GetCurrentLayer(); int roofHits = Physics2D.OverlapBoxNonAlloc(roofCheck.position, roofCheck.lossyScale , roofCheck.eulerAngles.z, overlapResults, currentLayer); return(roofHits > 0); }
public void Update() { if (!this.started) { return; } if (!this.shouldAppear) { float delta = Time.time - this.startTime; if (delta < this.duration) { this.animator.enabled = true; SetProgress(Mathf.Clamp01((delta - this.animationDuration) / (this.duration - this.animationDuration))); } if (!this.disappeared && delta > this.duration) { this.coll.enabled = false; this.animator.enabled = false; this.disappeared = true; SetProgress(1); } else if (this.disappeared && delta > this.duration + this.wait) { this.shouldAppear = true; } } if (this.shouldAppear) { int count = Physics2D.OverlapBoxNonAlloc(this.transform.position, this.coll.size, 0, this.overlapResults); bool doAppear = true; for (int i = 0; i < count; i++) { if (this.overlapResults[i].gameObject.tag == "Actor") { doAppear = false; } } if (doAppear) { this.coll.enabled = true; this.rend.sprite = this.animator.animations[0].frames[0]; this.animator.enabled = false; this.animator.SetFrame(0); this.disappeared = false; this.started = false; StartCoroutine(ReappearCor()); this.shouldAppear = false; } } }
protected override void OnUpdate() { var detectors = _entityQuery.ToComponentDataArray <DetectorComponent>(Allocator.TempJob); var colliders = _entityQuery.ToComponentArray <BoxCollider2D>(); var transforms = _entityQuery.ToComponentArray <Transform>(); var entities = _entityQuery.ToEntityArray(Allocator.TempJob); for (var i = 0; i < detectors.Length; i++) { var detector = detectors[i]; var transform = transforms[i]; var collider = colliders[i]; var count = Physics2D.OverlapBoxNonAlloc(transform.position, collider.size, transform.rotation.eulerAngles.z, _colliders, _triggerMask); detector.TriggersCount = count; var triggerIds = new NativeArray <int>(count, Allocator.Temp); for (int j = 0; j < count; j++) { triggerIds[j] = _colliders[j].GetInstanceID(); } int triggersHash = Utils.CombineHashCodes(triggerIds); if (detector.TriggersHash != triggersHash) { detector.TriggersHash = triggersHash; DynamicBuffer <ColliderId> buffer = EntityManager.GetBuffer <ColliderId>(entities[i]); buffer.Clear(); for (var index = 0; index < triggerIds.Length; index++) { int id = triggerIds[index]; buffer.Add(new ColliderId { Value = id }); } } detectors[i] = detector; triggerIds.Dispose(); } _entityQuery.CopyFromComponentDataArray(detectors); entities.Dispose(); detectors.Dispose(); }
// Update is called once per frame private void Update() { #region Hotkeys /*if (Input.GetKeyDown(KeyCode.B)) * { * buildMode = !buildMode; * if (buildMode) * { * StartBuildMode(); * } * else * { * StopBuildMode(); * } * } * * if (Input.GetKeyDown(KeyCode.D)) * { * buildMode = false; * selectionManager.CancelSelection(); * * selectionManager.StartTargetedSelection(SelectionMode.Building, * new SelectionManager.SelectionInfo<Transform>(OnSelectBuildingToDemolish, * OnCancelDemolish, * (obj) => obj.GetComponent<Construction.Modules.BuildingBase>() != null, * (t) => { return t; })); * } */ #endregion Hotkeys if (buildMode) { Vector3 pos = mainCam.ScreenToWorldPoint(Input.mousePosition) + (Vector3.forward * 10); Vector3 snappedPos = new Vector3((int)pos.x, (int)pos.y, 0); blueprintTransform.transform.position = snappedPos; int obstructingCount = Physics2D.OverlapBoxNonAlloc(snappedPos, blueprintTransform.bounds.size * .95f, 0, obstructingColliders, buildingLayerMask); bool obstruction = obstructingCount > 0; blueprintTransform.color = obstruction ? nonplaceableBlueprintColor : placeableBlueprintColor; if (!obstruction && Input.GetKeyDown(KeyCode.Mouse0)) { OnFindBuildPosition(snappedPos); } else if (Input.GetKeyDown(KeyCode.Escape)) { StopBuildMode(); } } }
public void SearchPlayer() { Collider2D[] hits = new Collider2D[1]; int result = Physics2D.OverlapBoxNonAlloc(transform.position, detectRange, 0, hits, 1 << 9); if (result > 0) { target = Game.player(); StopCoroutine("SearchTimer"); } }
private void Update() { Vector3 pos = (Vector2.one * Hurtbox.transform.position) + Hurtbox.offset; float angle = Hurtbox.transform.rotation.eulerAngles.z; int hits = Physics2D.OverlapBoxNonAlloc(pos, Hurtbox.size, angle, colliderHits, HitMask); for (int i = 0; i < hits; ++i) { string name = colliderHits[i].gameObject.name; Debug.Log("hit: " + name); } }
private bool IsPossibileMovement(Vector2 direction) { colliderCenter = rigidBody.position + boxCollider.offset; collisionsNumber = Physics2D.OverlapBoxNonAlloc(colliderCenter + direction, boxCollider.size, 0, hits); for (int i = 0; i < collisionsNumber; i++) { if (!hits[i].isTrigger && hits[i].gameObject.GetInstanceID() != ID) { return(false); } } return(true); }