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);
}
