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