public FPVector[] TestCollision(HurtBox[] hurtBoxes, HitConfirmType hitConfirmType)
{
if (isHit && hitConfirmType == HitConfirmType.Hit)
{
return(new FPVector[0]);
}
foreach (HitBox hitbox in this.hitBoxes)
{
if (hitbox.followXBounds || hitbox.followYBounds)
{
hitbox.rendererBounds = GetBounds();
}
}
return(HitBoxesScript.TestCollision(worldTransform.position, this.hitBoxes, hurtBoxes, hitConfirmType, controlsScript.mirror));
}
public Vector3[] TestCollision(HurtBox[] hurtBoxes, HitConfirmType hitConfirmType)
{
if (isHit && hitConfirmType == HitConfirmType.Hit)
{
return new Vector3[] { }
}
;
foreach (HitBox hitbox in this.hitBoxes)
{
if (hitbox.followXBounds || hitbox.followYBounds)
{
hitbox.rendererBounds = GetBounds();
}
}
return(HitBoxesScript.TestCollision(this.hitBoxes, hurtBoxes, hitConfirmType, controlsScript.mirror));
}
public Vector3 TestCollision(HurtBox[] hurtBoxes, HitConfirmType hitConfirmType)
{
if (isHit && hitConfirmType == HitConfirmType.Hit)
{
return(Vector3.zero);
}
foreach (HitBox hitbox in this.hitBoxes)
{
if (hitbox.followXBounds || hitbox.followYBounds)
{
hitbox.rendererBounds = GetBounds();
}
}
/*Vector3 result = HitBoxesScript.TestCollision(this.hitBoxes, hurtBoxes, hitConfirmType, controlsScript.mirror);
* if (result == Vector3.zero) {
* foreach (HitBox hitBox in hitBoxes) {
* if (hitBox.state == 1) hitBox.state = 0;
* }
* }*/
return(HitBoxesScript.TestCollision(this.hitBoxes, hurtBoxes, hitConfirmType, controlsScript.mirror));
}
public static Vector3 TestCollision(HitBox[] hitBoxes, HurtBox[] hurtBoxes, HitConfirmType hitConfirmType, int mirror)
{
foreach (HitBox hitBox in hitBoxes)
{
if (hitBox.hide)
{
continue;
}
if (hitBox.collisionType == CollisionType.noCollider)
{
continue;
}
if (hitConfirmType == HitConfirmType.Throw && hitBox.collisionType != CollisionType.throwCollider)
{
continue;
}
if (hitConfirmType == HitConfirmType.Hit && hitBox.collisionType == CollisionType.throwCollider)
{
continue;
}
hitBox.state = 0;
foreach (HurtBox hurtBox in hurtBoxes)
{
Vector3 hurtBoxPosition = hurtBox.position;
Vector3 hitBoxPosition = hitBox.position.position;
float dist = 0;
bool collisionConfirm = false;
if (!UFE.config.detect3D_Hits)
{
hurtBoxPosition.z = -1;
hitBoxPosition.z = -1;
}
if (hurtBox.shape == HitBoxShape.circle)
{
if (hitBox.shape == HitBoxShape.circle)
{
dist = Vector3.Distance(hurtBoxPosition, hitBoxPosition);
if (dist <= hurtBox.radius + hitBox.radius)
{
collisionConfirm = true;
}
}
else if (hitBox.shape == HitBoxShape.rectangle)
{
float mirrorDiff = mirror > 0 ? hitBox.rect.width : 0f;
Rect hitBoxRectanglePosition = new Rect(((hitBox.rect.x + mirrorDiff) * mirror) + hitBoxPosition.x,
hitBox.rect.y + hitBoxPosition.y,
hitBox.rect.width, hitBox.rect.height);
if (hitBox.followXBounds)
{
hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width / 2);
hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds)
{
hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height / 2);
hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
dist = distancePointToRectangle(hurtBoxPosition, hitBoxRectanglePosition);
if (dist <= hurtBox.radius)
{
collisionConfirm = true;
}
}
}
else if (hurtBox.shape == HitBoxShape.rectangle)
{
Rect hurtBoxRectanglePosition;
if (hitBox.shape == HitBoxShape.circle)
{
float mirrorDiff = mirror < 0 ? hurtBox.rect.width : 0f;
hurtBoxRectanglePosition = new Rect(((hurtBox.rect.x + mirrorDiff) * mirror) + hurtBoxPosition.x,
hurtBox.rect.y + hurtBoxPosition.y,
hurtBox.rect.width, hurtBox.rect.height);
if (hurtBox.followXBounds)
{
hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width / 2);
hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds)
{
hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height / 2);
hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
dist = distancePointToRectangle(hitBoxPosition, hurtBoxRectanglePosition);
if (dist <= hitBox.radius)
{
collisionConfirm = true;
}
}
else if (hitBox.shape == HitBoxShape.rectangle)
{
float mirrorDiff = mirror < 0 ? hurtBox.rect.width : 0f;
hurtBoxRectanglePosition = new Rect(((hurtBox.rect.x + mirrorDiff) * mirror) + hurtBoxPosition.x,
hurtBox.rect.y + hurtBoxPosition.y,
hurtBox.rect.width, hurtBox.rect.height);
mirrorDiff = mirror > 0 ? hitBox.rect.width : 0f;
Rect hitBoxRectanglePosition = new Rect(((hitBox.rect.x + mirrorDiff) * -mirror) + hitBoxPosition.x,
hitBox.rect.y + hitBoxPosition.y,
hitBox.rect.width, hitBox.rect.height);
if (hitBox.followXBounds)
{
hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width / 2);
hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds)
{
hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height / 2);
hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
if (hurtBox.followXBounds)
{
hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width / 2);
hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds)
{
hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height / 2);
hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
if (hurtBoxRectanglePosition.Overlaps(hitBoxRectanglePosition))
{
collisionConfirm = true;
}
}
}
if (collisionConfirm)
{
if (hitConfirmType == HitConfirmType.Hit)
{
hitBox.state = 1;
}
return((hurtBoxPosition + hitBoxPosition) / 2);
}
}
}
foreach (HitBox hitBox in hitBoxes)
{
if (hitBox.state == 1)
{
hitBox.state = 0;
}
}
return(Vector3.zero);
}
public static FPVector[] TestCollision(FPVector rootPosition, HitBox[] hitBoxes, HurtBox[] hurtBoxes, HitConfirmType hitConfirmType, int mirror)
{
foreach (HitBox hitBox in hitBoxes)
{
if (hitBox.hide)
{
continue;
}
if (hitBox.collisionType == CollisionType.noCollider)
{
continue;
}
if (hitConfirmType == HitConfirmType.Throw && hitBox.collisionType != CollisionType.throwCollider)
{
continue;
}
if (hitConfirmType == HitConfirmType.Hit && hitBox.collisionType == CollisionType.throwCollider)
{
continue;
}
hitBox.state = 0;
//drawRect.Clear();
foreach (HurtBox hurtBox in hurtBoxes)
{
FPVector hurtBoxPosition = hurtBox.position;
FPVector hitBoxPosition = hitBox.mappedPosition + rootPosition;
Fix64 dist = 0;
bool collisionConfirm = false;
if (!UFE.config.detect3D_Hits)
{
hurtBoxPosition.z = 0;
hitBoxPosition.z = 0;
}
if (hurtBox.shape == HitBoxShape.circle)
{
if (hitBox.shape == HitBoxShape.circle)
{
dist = FPVector.Distance(hurtBoxPosition, hitBoxPosition);
if (dist <= hurtBox._radius + hitBox._radius)
{
collisionConfirm = true;
}
}
else if (hitBox.shape == HitBoxShape.rectangle)
{
FPRect hitBoxRectanglePosition = hitBox._rect;
hitBoxRectanglePosition.x += hitBoxPosition.x;
hitBoxRectanglePosition.y += hitBoxPosition.y;
hitBoxRectanglePosition.RefreshPoints();
if (hitBox.followXBounds)
{
//hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width / 2);
//hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds)
{
//hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height / 2);
//hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
dist = hitBoxRectanglePosition.DistanceToPoint(hurtBoxPosition);
if (hurtBox._radius >= dist)
{
collisionConfirm = true;
}
/*if (collisionConfirm && !hurtBox.isBlock) {
* Debug.Log("------------------");
* Debug.Log(hurtBoxPosition);
* Debug.Log(hitBox.bodyPart + " - " + hitBoxRectanglePosition);
* Debug.Log("xMin/xMax,yMin/yMax : " + hitBoxRectanglePosition.xMin + "/" + hitBoxRectanglePosition.xMax + ", " + hitBoxRectanglePosition.yMin + "/" + hitBoxRectanglePosition.yMax);
* Debug.Log(hurtBox.radius + " >= " + dist + " = " + collisionConfirm);
* }*/
}
}
else if (hurtBox.shape == HitBoxShape.rectangle)
{
FPRect hurtBoxRectanglePosition = hurtBox._rect;
if (mirror < 0)
{
hurtBoxRectanglePosition.x += hurtBoxRectanglePosition.width;
}
hurtBoxRectanglePosition.x *= mirror;
hurtBoxRectanglePosition.x += hurtBoxPosition.x;
hurtBoxRectanglePosition.y += hurtBoxPosition.y;
hurtBoxRectanglePosition.RefreshPoints();
if (hitBox.shape == HitBoxShape.circle)
{
if (hurtBox.followXBounds)
{
//hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width/2);
//hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds)
{
//hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height/2);
//hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
dist = hurtBoxRectanglePosition.DistanceToPoint(hitBoxPosition);
if (dist <= hitBox._radius)
{
collisionConfirm = true;
}
}
else if (hitBox.shape == HitBoxShape.rectangle)
{
FPRect hitBoxRectanglePosition = hitBox._rect;
//if (mirror > 0) hitBoxRectanglePosition.x += hitBoxRectanglePosition.width;
//hitBoxRectanglePosition.x *= -mirror;
hitBoxRectanglePosition.x += hitBoxPosition.x;
hitBoxRectanglePosition.y += hitBoxPosition.y;
hitBoxRectanglePosition.RefreshPoints();
if (hitBox.followXBounds)
{
//hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width/2);
//hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds)
{
//hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height/2);
//hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
if (hurtBox.followXBounds)
{
//hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width/2);
//hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds)
{
//hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height/2);
//hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
if (hurtBoxRectanglePosition.Intersects(hitBoxRectanglePosition))
{
collisionConfirm = true;
}
}
}
if (collisionConfirm)
{
if (hitConfirmType == HitConfirmType.Hit)
{
hitBox.state = 1;
}
return(new FPVector[] { hurtBoxPosition, hitBoxPosition, (hurtBoxPosition + hitBoxPosition) / 2 });
}
}
}
foreach (HitBox hitBox in hitBoxes)
{
if (hitBox.state == 1)
{
hitBox.state = 0;
}
}
return(new FPVector[0]);
}
public static Vector3[] TestCollision(HitBox[] hitBoxes, HurtBox[] hurtBoxes, HitConfirmType hitConfirmType, int mirror)
{
foreach (HitBox hitBox in hitBoxes)
{
if (hitBox.hide)
{
continue;
}
if (hitBox.collisionType == CollisionType.noCollider)
{
continue;
}
if (hitConfirmType == HitConfirmType.Throw && hitBox.collisionType != CollisionType.throwCollider)
{
continue;
}
if (hitConfirmType == HitConfirmType.Hit && hitBox.collisionType == CollisionType.throwCollider)
{
continue;
}
hitBox.state = 0;
//drawRect.Clear();
foreach (HurtBox hurtBox in hurtBoxes)
{
Vector3 hurtBoxPosition = hurtBox.position;
Vector3 hitBoxPosition = hitBox.position.position;
float dist = 0;
bool collisionConfirm = false;
if (!UFE.config.detect3D_Hits)
{
hurtBoxPosition.z = -1;
hitBoxPosition.z = -1;
}
if (hurtBox.shape == HitBoxShape.circle)
{
if (hitBox.shape == HitBoxShape.circle)
{
dist = Vector3.Distance(hurtBoxPosition, hitBoxPosition);
if (dist <= hurtBox.radius + hitBox.radius)
{
collisionConfirm = true;
}
}
else if (hitBox.shape == HitBoxShape.rectangle)
{
Rect hitBoxRectanglePosition = new Rect(hitBox.rect);
hitBoxRectanglePosition.x *= -mirror;
hitBoxRectanglePosition.width *= -mirror;
hitBoxRectanglePosition.x += hitBoxPosition.x;
hitBoxRectanglePosition.y += hitBoxPosition.y;
if (hitBox.followXBounds)
{
hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width / 2);
hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds)
{
hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height / 2);
hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
dist = distancePointToRectangle(hurtBoxPosition, hitBoxRectanglePosition);
if (hurtBox.radius >= dist)
{
collisionConfirm = true;
}
/*if (collisionConfirm && !hurtBox.isBlock) {
* Debug.Log("------------------");
* Debug.Log(hurtBoxPosition);
* Debug.Log(hitBox.bodyPart + " - " + hitBoxRectanglePosition);
* Debug.Log("xMin/xMax,yMin/yMax : " + hitBoxRectanglePosition.xMin + "/" + hitBoxRectanglePosition.xMax + ", " + hitBoxRectanglePosition.yMin + "/" + hitBoxRectanglePosition.yMax);
* Debug.Log(hurtBox.radius + " >= " + dist + " = " + collisionConfirm);
* }*/
}
}
else if (hurtBox.shape == HitBoxShape.rectangle)
{
/* Overlap doesn't work with negative width
* Rect hurtBoxRectanglePosition = new Rect(hurtBox.rect);
* hurtBoxRectanglePosition.x *= -mirror;
* hurtBoxRectanglePosition.width *= -mirror;
* hurtBoxRectanglePosition.x += hurtBoxPosition.x;
* hurtBoxRectanglePosition.y += hurtBoxPosition.y;*/
float mirrorDiff = mirror < 0 ? hurtBox.rect.width : 0f;
Rect hurtBoxRectanglePosition = new Rect(((hurtBox.rect.x + mirrorDiff) * mirror) + hurtBoxPosition.x,
hurtBox.rect.y + hurtBoxPosition.y,
hurtBox.rect.width, hurtBox.rect.height);
if (hitBox.shape == HitBoxShape.circle)
{
if (hurtBox.followXBounds)
{
hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width / 2);
hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds)
{
hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height / 2);
hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
dist = distancePointToRectangle(hitBoxPosition, hurtBoxRectanglePosition);
if (dist <= hitBox.radius)
{
collisionConfirm = true;
}
}
else if (hitBox.shape == HitBoxShape.rectangle)
{
/* Overlap doesn't work with negative width
* Rect hitBoxRectanglePosition = new Rect(hitBox.rect);
* hitBoxRectanglePosition.x *= -mirror;
* hitBoxRectanglePosition.width *= -mirror;
* hitBoxRectanglePosition.x += hitBoxPosition.x;
* hitBoxRectanglePosition.y += hitBoxPosition.y;*/
mirrorDiff = mirror > 0 ? hitBox.rect.width : 0f;
Rect hitBoxRectanglePosition = new Rect(((hitBox.rect.x + mirrorDiff) * -mirror) + hitBoxPosition.x,
hitBox.rect.y + hitBoxPosition.y,
hitBox.rect.width, hitBox.rect.height);
if (hitBox.followXBounds)
{
hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width / 2);
hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds)
{
hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height / 2);
hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
if (hurtBox.followXBounds)
{
hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width / 2);
hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds)
{
hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height / 2);
hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
if (hurtBoxRectanglePosition.Overlaps(hitBoxRectanglePosition))
{
collisionConfirm = true;
}
}
}
if (collisionConfirm)
{
if (hitConfirmType == HitConfirmType.Hit)
{
hitBox.state = 1;
}
return(new Vector3[] { hurtBoxPosition, hitBoxPosition, (hurtBoxPosition + hitBoxPosition) / 2 });
}
}
}
foreach (HitBox hitBox in hitBoxes)
{
if (hitBox.state == 1)
{
hitBox.state = 0;
}
}
return(new Vector3[] { });
}
public Vector3 TestCollision(HurtBox[] hurtBoxes, HitConfirmType hitConfirmType)
{
if (isHit && hitConfirmType == HitConfirmType.Hit) return Vector3.zero;
foreach(HitBox hitbox in this.hitBoxes) if (hitbox.followXBounds || hitbox.followYBounds) hitbox.rendererBounds = GetBounds();
/*Vector3 result = HitBoxesScript.TestCollision(this.hitBoxes, hurtBoxes, hitConfirmType, controlsScript.mirror);
if (result == Vector3.zero) {
foreach (HitBox hitBox in hitBoxes) {
if (hitBox.state == 1) hitBox.state = 0;
}
}*/
return HitBoxesScript.TestCollision(this.hitBoxes, hurtBoxes, hitConfirmType, controlsScript.mirror);
}
public static Vector3 TestCollision(HitBox[] hitBoxes, HurtBox[] hurtBoxes, HitConfirmType hitConfirmType, int mirror)
{
foreach (HitBox hitBox in hitBoxes) {
if (hitBox.hide) continue;
if (hitBox.collisionType == CollisionType.noCollider) continue;
if (hitConfirmType == HitConfirmType.Throw && hitBox.collisionType != CollisionType.throwCollider) continue;
if (hitConfirmType == HitConfirmType.Hit && hitBox.collisionType == CollisionType.throwCollider) continue;
hitBox.state = 0;
foreach (HurtBox hurtBox in hurtBoxes) {
Vector3 hurtBoxPosition = hurtBox.position;
Vector3 hitBoxPosition = hitBox.position.position;
float dist = 0;
bool collisionConfirm = false;
if (!UFE.config.detect3D_Hits){
hurtBoxPosition.z = -1;
hitBoxPosition.z = -1;
}
if (hurtBox.shape == HitBoxShape.circle){
if (hitBox.shape == HitBoxShape.circle){
dist = Vector3.Distance(hurtBoxPosition, hitBoxPosition);
if (dist <= hurtBox.radius + hitBox.radius) collisionConfirm = true;
}else if (hitBox.shape == HitBoxShape.rectangle){
float mirrorDiff = mirror > 0 ? hitBox.rect.width : 0f;
Rect hitBoxRectanglePosition = new Rect(((hitBox.rect.x + mirrorDiff) * mirror) + hitBoxPosition.x,
hitBox.rect.y + hitBoxPosition.y,
hitBox.rect.width, hitBox.rect.height);
if (hitBox.followXBounds){
hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width/2);
hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds){
hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height/2);
hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
dist = distancePointToRectangle(hurtBoxPosition, hitBoxRectanglePosition);
if (dist <= hurtBox.radius) collisionConfirm = true;
}
}else if (hurtBox.shape == HitBoxShape.rectangle){
Rect hurtBoxRectanglePosition;
if (hitBox.shape == HitBoxShape.circle){
float mirrorDiff = mirror < 0 ? hurtBox.rect.width : 0f;
hurtBoxRectanglePosition = new Rect(((hurtBox.rect.x + mirrorDiff) * mirror) + hurtBoxPosition.x,
hurtBox.rect.y + hurtBoxPosition.y,
hurtBox.rect.width, hurtBox.rect.height);
if (hurtBox.followXBounds){
hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width/2);
hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds){
hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height/2);
hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
dist = distancePointToRectangle(hitBoxPosition, hurtBoxRectanglePosition);
if (dist <= hitBox.radius) collisionConfirm = true;
}else if (hitBox.shape == HitBoxShape.rectangle){
float mirrorDiff = mirror < 0 ? hurtBox.rect.width : 0f;
hurtBoxRectanglePosition = new Rect(((hurtBox.rect.x + mirrorDiff) * mirror) + hurtBoxPosition.x,
hurtBox.rect.y + hurtBoxPosition.y,
hurtBox.rect.width, hurtBox.rect.height);
mirrorDiff = mirror > 0 ? hitBox.rect.width : 0f;
Rect hitBoxRectanglePosition = new Rect(((hitBox.rect.x + mirrorDiff) * - mirror) + hitBoxPosition.x,
hitBox.rect.y + hitBoxPosition.y,
hitBox.rect.width, hitBox.rect.height);
if (hitBox.followXBounds){
hitBoxRectanglePosition.x = hitBox.rendererBounds.x - (hitBox.rect.width/2);
hitBoxRectanglePosition.width = (hitBox.rendererBounds.width + hitBox.rect.width) - hitBox.rendererBounds.x;
}
if (hitBox.followYBounds){
hitBoxRectanglePosition.y = hitBox.rendererBounds.y - (hitBox.rect.height/2);
hitBoxRectanglePosition.height = (hitBox.rendererBounds.height + hitBox.rect.height) - hitBox.rendererBounds.y;
}
if (hurtBox.followXBounds){
hurtBoxRectanglePosition.x = hurtBox.rendererBounds.x - (hurtBox.rect.width/2);
hurtBoxRectanglePosition.width = (hurtBox.rendererBounds.width + hurtBox.rect.width) - hurtBox.rendererBounds.x;
}
if (hurtBox.followYBounds){
hurtBoxRectanglePosition.y = hurtBox.rendererBounds.y - (hurtBox.rect.height/2);
hurtBoxRectanglePosition.height = (hurtBox.rendererBounds.height + hurtBox.rect.height) - hurtBox.rendererBounds.y;
}
if (hurtBoxRectanglePosition.Overlaps(hitBoxRectanglePosition)) collisionConfirm = true;
}
}
if (collisionConfirm) {
if (hitConfirmType == HitConfirmType.Hit) {
hitBox.state = 1;
}
return (hurtBoxPosition + hitBoxPosition)/2;
}
}
}
foreach (HitBox hitBox in hitBoxes) {
if (hitBox.state == 1) hitBox.state = 0;
}
return Vector3.zero;
}
