public static bool Raycast(Ray ray, out RaycastHit raycastHit, RaycastData raycastData) => Physics.Raycast(
ray: ray,
hitInfo: out raycastHit,
maxDistance: raycastData._MaxDistance,
layerMask: raycastData._LayerMask,
queryTriggerInteraction: raycastData._QueryTriggerInteraction
);
private RaycastData GetDominantCornerAxis(Vector2 rayOrigin, Vector2 rayXDirection, Vector2 rayYDirection, float rayLength)
{
float rayXOverlapFraction = GetRayOverlapFraction(rayOrigin, rayXDirection, rayLength);
float rayYOverlapFraction = GetRayOverlapFraction(rayOrigin, rayYDirection, rayLength);
if (rayXOverlapFraction == 0 && rayYOverlapFraction == 0)
{
return(new RaycastData());
}
RaycastData raycastData = new RaycastData();
float distance = 0;
bool rayXIsDominant = rayXOverlapFraction > rayYOverlapFraction;
if (rayXIsDominant)
{
CheckRaycastOther(rayOrigin, rayXDirection, rayLength, layers, out distance);
raycastData.Distance = new Vector2(distance, 0);
raycastData.Direction = Vector2.right;
}
else
{
CheckRaycastOther(rayOrigin, rayXDirection, rayLength, layers, out distance);
raycastData.Distance = new Vector2(0, distance);
raycastData.Direction = Vector2.up;
}
return(raycastData);
}
protected override void OnUpdate()
{
foreach (CollisionEntityFilter entity in GetEntities <CollisionEntityFilter>())
{
Velocity velocity = entity.VelocityComponent;
CollisionData collisionData = entity.CollisionComponent;
BoxCollider2D collider = entity.ColliderComponent;
collisionData.previousSlopeAngle = collisionData.slopeAngle;
ResetCollisionState(collisionData);
float2 delta = velocity.Delta;
RaycastData raycastData = CalculateRaycastData(collider, collisionData);
if (delta.y < 0)
{
HandleSlopeDecend(ref delta, collider.edgeRadius, collisionData, raycastData);
}
if (delta.x != 0)
{
HandleHorizontalCollisions(ref delta, collider.edgeRadius, collisionData, raycastData);
}
if (delta.y != 0)
{
HandleVerticalCollision(ref delta, collider.edgeRadius, collisionData, raycastData);
}
NeutralizeVelocity(ref velocity, collisionData);
velocity.Delta = delta;
}
}
private void Initialize()
{
if (!character)
{
character = GameObject.Find("Character");
}
if (!boxCollider)
{
boxCollider = GetComponent <BoxCollider2D>();
}
if (SettingsIsNull)
{
settings = CreateInstance <RaycastSettings>();
}
if (InitializePlatformerController)
{
platformerController = GetComponent <PlatformerController>();
}
if (InitializeLayerMaskController)
{
layerMaskController = GetComponent <LayerMaskController>();
}
if (InitializePhysicsController)
{
physicsController = GetComponent <PhysicsController>();
}
if (DataIsNull)
{
Data = CreateInstance <RaycastData>();
}
Data.OnInitialize(ref boxCollider, ref character, settings);
}
MeshEdgePosition FindMeshEdgePosition(RaycastData minimumViewCast, RaycastData maximumViewCast)
{
float minAngle = minimumViewCast.Angle;
float maxAngle = maximumViewCast.Angle;
Vector3 minPoint = minimumViewCast.Point;
Vector3 maxPoint = maximumViewCast.Point;
for (int i = 0; i < EdgePrecision; i++)
{
float angle = (minAngle + maxAngle) / 2;
RaycastData newViewCast = RaycastAtAngle(angle);
bool thresholdExceeded = Mathf.Abs(minimumViewCast.Distance - newViewCast.Distance) > EdgeThreshold;
if (newViewCast.Hit = minimumViewCast.Hit && !thresholdExceeded)
{
minAngle = angle;
minPoint = newViewCast.Point;
}
else
{
maxAngle = angle;
maxPoint = newViewCast.Point;
}
}
return(new MeshEdgePosition(minPoint, maxPoint));
}
private RaycastData CalculateRaycastData(BoxCollider2D collider, CollisionData collisionData)
{
RaycastData data = new RaycastData();
float skinWidth = collider.edgeRadius;
Bounds bounds = collider.bounds;
bounds.Expand(skinWidth * -2f);
data.TopLeft = new Vector2(bounds.min.x, bounds.max.y);
data.TopRight = bounds.max;
data.BottomLeft = bounds.min;
data.BottomRight = new Vector2(bounds.max.x, bounds.min.y);
int horizontalRayCount = collisionData.HorizontalRayCount;
int verticalRayCount = collisionData.VerticalRayCount;
float horizontalSpacing = bounds.size.y / (horizontalRayCount - 1);
float verticalSpacing = bounds.size.x / (verticalRayCount - 1);
data.HorizontalRayCount = horizontalRayCount;
data.VerticalRayCount = verticalRayCount;
data.HorizontalRaySpacing = horizontalSpacing;
data.VerticalRaySpacing = verticalSpacing;
return(data);
}
protected virtual void DrawMesh()
{
int steps = Mathf.RoundToInt(MeshDensity * VisionAngle);
float stepsAngle = VisionAngle / steps;
List <Vector3> viewPoints = new List <Vector3>();
RaycastData oldViewCast = new RaycastData();
for (int i = 0; i <= steps; i++)
{
float angle = stepsAngle * i + EulerAngles.y - VisionAngle / 2f;
RaycastData viewCast = RaycastAtAngle(angle);
if (i > 0)
{
bool thresholdExceeded = Mathf.Abs(oldViewCast.Distance - viewCast.Distance) > EdgeThreshold;
if ((oldViewCast.Hit != viewCast.Hit) ||
(oldViewCast.Hit && viewCast.Hit && thresholdExceeded))
{
MeshEdgePosition edge = FindMeshEdgePosition(oldViewCast, viewCast);
if (edge.PointA != Vector3.zero)
{
viewPoints.Add(edge.PointA);
}
if (edge.PointB != Vector3.zero)
{
viewPoints.Add(edge.PointB);
}
}
}
viewPoints.Add(viewCast.Point);
oldViewCast = viewCast;
}
int numberOfVertices = viewPoints.Count + 1;
Vector3[] vertices = new Vector3[numberOfVertices];
int[] triangles = new int[(numberOfVertices - 2) * 3];
vertices[0] = Vector3.zero + Offset;
for (int i = 0; i < numberOfVertices - 1; i++)
{
vertices[i + 1] = this.transform.InverseTransformPoint(viewPoints[i]);
if (i < numberOfVertices - 2)
{
triangles[i * 3] = 0;
triangles[i * 3 + 1] = i + 1;
triangles[i * 3 + 2] = i + 2;
}
}
_visionMesh.Clear();
_visionMesh.vertices = vertices;
_visionMesh.triangles = triangles;
_visionMesh.RecalculateNormals();
}
private RaycastData GetCornerBottomLeftRaycastData()
{
RaycastData bottomLeftCornerRaycastData = GetDominantCornerAxis(bottomLeftCornerPoint.position, leftUpDirection, rightDownDirection, cornerRayLength);
Vector2 bottomLeftCornerDirection = new Vector2(bottomLeftCornerRaycastData.Direction.x * -1, bottomLeftCornerRaycastData.Direction.y * -1);
return(new RaycastData()
{
Direction = bottomLeftCornerDirection,
Distance = bottomLeftCornerRaycastData.Distance
});
}
private RaycastData GetCornerTopLeftRaycastData()
{
RaycastData topLeftCornerRaycastData = GetDominantCornerAxis(topLeftCornerPoint.position, leftDownDirection, rightUpDirection, cornerRayLength);
Vector2 topLeftCornerDirection = new Vector2(topLeftCornerRaycastData.Direction.x * -1, topLeftCornerRaycastData.Direction.y);
return(new RaycastData()
{
Direction = topLeftCornerDirection,
Distance = topLeftCornerRaycastData.Distance
});
}
public RaycastData GetCombinedDirectionAndCenterDistances()
{
RaycastData centerRaycastData = GetCenterRaycastData();
Vector2 cornersDirection = GetCornersDirection();
Vector2 combinedDirection = centerRaycastData.Direction + cornersDirection;
Vector2 raycastDataDirection = VectorHelper.Clamp(combinedDirection, -1, 1);
return(new RaycastData()
{
Direction = raycastDataDirection,
Distance = centerRaycastData.Distance
});
}
public RaycastData GetCornersRaycastData()
{
RaycastData topRightRaycastData = GetCornerTopRightRaycastData();
RaycastData topLeftRaycastData = GetCornerTopLeftRaycastData();
RaycastData bottomRightRaycastData = GetCornerBottomRightRaycastData();
RaycastData bottomLeftRaycastData = GetCornerBottomLeftRaycastData();
Vector2 combinedCornerDirection = topRightRaycastData.Direction +
topLeftRaycastData.Direction +
bottomRightRaycastData.Direction +
bottomLeftRaycastData.Direction;
Vector2 raycastDataDirection = VectorHelper.Clamp(combinedCornerDirection, -1, 1);
List <Vector2> distances = new List <Vector2>()
{
topRightRaycastData.Distance,
topLeftRaycastData.Distance,
bottomRightRaycastData.Distance,
bottomLeftRaycastData.Distance,
};
Vector2 raycastDataDistance = new Vector2();
foreach (Vector2 distance in distances)
{
if (distance.x != 0)
{
raycastDataDistance = new Vector2(distance.x, raycastDataDistance.y);
}
else if (distance.y != 0)
{
raycastDataDistance = new Vector2(raycastDataDistance.x, distance.y);
}
}
return(new RaycastData()
{
Direction = raycastDataDirection,
Distance = raycastDataDistance
});
}
protected override void Execute()
{
Vector2 moveDirection;
if (playerVelocityRef.Get().IsMovingStandard)
{
moveDirection = playerVelocityRef.Get().MoveDirection;
}
else
{
moveDirection = playerVelocityRef.Get().GetPreviousVelocityDirection();
}
Vector2 collisionDirection = playerCollisionDirectionRef.Get().CollisionDirection;
RaycastData combinedRaycastData = playerRaycastDirectionRef.Get().GetCombinedDirectionAndCenterDistances();
Vector2 surroundingsDirection = SurroundingDirectionHelper.GetSurroundingsDirection(collisionDirection, combinedRaycastData.Direction);
playerMoveDirectionRef.Get().TurnToNextDirection(moveDirection, surroundingsDirection, collisionDirection, combinedRaycastData.Distance);
}
/// <summary>
/// Get the slope direction between the closest point to a surface and the hit point in the raycast direction.
/// </summary>
/// <param name="raycastData"></param>
/// <param name="surfaceGradient"></param>
/// <returns></returns>
public static bool tryFindSurfaceGradient(ref RaycastData raycastData, out Vector3 surfaceGradient)
{
bool success = false;
surfaceGradient = Vector3.zero;
RaycastHit hit;
if (Physics.Raycast(raycastData.sourceTransform.position, raycastData.direction, out hit, raycastData.checkDistance, raycastData.surfaceLayerMask))
{
RaycastHit closestSurfacePointHit;
if (Physics.Raycast(raycastData.sourceTransform.position, hit.normal * -1, out closestSurfacePointHit, raycastData.checkDistance, raycastData.surfaceLayerMask))
{
//Vector3 hitDirection = hit.point - raycastData.sourceTransform.position;
surfaceGradient = hit.point - closestSurfacePointHit.point;
success = true;
}
}
return(success);
}
private IEnumerator OnShowExtra()
{
foreach (var data in ExtraRatios)
{
List <GroundController> org = new List <GroundController> ();
org.Add(data.gc);
recJobRatios [data.extraJob] += data.upRatio;
for (int i = 0; i < recAllRatioData.Count; i++)
{
if (recAllRatioData [i].start.name == data.linkData.ElementAt(0).Key.name&& recAllRatioData [i].end.name == data.linkData.ElementAt(0).Value.name)
{
RaycastData raycastdata = new RaycastData();
raycastdata = recAllRatioData [i];
raycastdata.ratio += data.upRatio;
recAllRatioData [i] = raycastdata;
}
}
for (int i = 0; i < fightController.players.Length; i++)
{
if (fightController.GetJob("P", i) == data.extraJob)
{
GroundSEController gse = SEPool.Dequeue();
gse.SetExtraSE(org, playerButtonPos [i], i, data.upRatio);
gse.onRecycle = RecycleExtraItem;
gse.onExtraUp = ExtraRatioUp;
SEingPool.Enqueue(gse);
AddCanAttack(i);
}
}
}
unShowed = SEingPool.Count;
while (SEingPool.Count > 0)
{
GroundSEController gse = SEingPool.Dequeue();
gse.gameObject.SetActive(true);
gse.Run();
yield return(new WaitForSeconds(0.2f));
}
}
private void HandleVerticalCollision(ref float2 movementDelta, float skinWidth, CollisionData collisionData, RaycastData raycastData)
{
float verticalDirection = math.sign(movementDelta.y);
float raycastDistance = math.abs(movementDelta.y) + skinWidth;
Vector2 raycastOrigin = (verticalDirection == 1) ? raycastData.TopLeft : raycastData.BottomLeft;
RaycastHit2D hit;
for (int i = 0; i < raycastData.VerticalRayCount; i++)
{
Vector2 ray = raycastOrigin + (Vector2.right * (raycastData.VerticalRaySpacing * i + movementDelta.x));
Debug.DrawRay(ray, Vector2.up * verticalDirection * raycastDistance, Color.red, 0.1f);
hit = Physics2D.Raycast(ray, Vector2.up * verticalDirection, raycastDistance, collisionData.Mask);
if (hit)
{
// ToDo one way playforms / moving platforms
movementDelta.y = (hit.distance - skinWidth) * verticalDirection;
raycastDistance = hit.distance;
if (collisionData.ascendingSlope)
{
movementDelta.x = movementDelta.y / math.tan(math.radians(collisionData.slopeAngle)) * math.sign(movementDelta.x);
}
collisionData.Above = (verticalDirection == 1);
collisionData.Below = (verticalDirection == -1);
}
}
if (collisionData.ascendingSlope)
{
float horizontalDirection = math.sign(movementDelta.x);
raycastDistance = math.abs(movementDelta.x) + skinWidth;
Vector2 ray = ((horizontalDirection == 1) ? raycastData.BottomRight : raycastData.BottomLeft) + (Vector2.up * movementDelta.y);
hit = Physics2D.Raycast(ray, Vector2.right * horizontalDirection, raycastDistance, collisionData.Mask);
if (hit)
{
float slopeAngle = Vector2.Angle(hit.normal, Vector2.up);
if (slopeAngle != collisionData.slopeAngle)
{
movementDelta.x = (hit.distance - skinWidth) * horizontalDirection;
collisionData.slopeAngle = slopeAngle;
}
}
}
}
/// <summary>
/// 向六方向射出射線進行偵測.
/// </summary>
/// <returns>The round.</returns>
/// <param name="isPrev">是否還原狀態 <c>true</c> is previous.</param>
/// <param name="isTouchUp">是否屏幕碰觸結束<c>true</c> is touch up.</param>
/// <param name="isEnd">是否結束此回合<c>true</c> is end.</param>
private List <RaycastData> RaycastRound(bool isPrev, bool isTouchUp, bool isEnd, bool isTest = false)
{
RaycastHit2D[] hits;
List <RaycastData> dataList = new List <RaycastData>();
bool hasActived = false;
for (int i = 0; i < 6; i++)
{
hits = transform.parent.GetComponent <GroundRaycastController>().GetRaycastHits(transform.position, new Vector2(Mathf.Sin(Mathf.Deg2Rad * (constAngle + constAngle + i * 60)), Mathf.Cos(Mathf.Deg2Rad * (constAngle + constAngle + i * 60))), 116f * 8);
if (hits.Length == 0)
{
continue;
}
bool hitNone = false;
bool hasOcclusion = false;
List <RaycastHit2D> hitGcs = new List <RaycastHit2D>();
for (int j = 0; j < hits.Length; j++)
{
hitGcs.Add(hits[j]);
if ((int)hits[j].transform.GetComponent <GroundController>()._groundType > 0 && (int)hits[j].transform.GetComponent <GroundController>()._groundType < 10)
{
hasOcclusion = true;
}
if ((int)hits[j].transform.GetComponent <GroundController>()._groundType == 0 || (int)hits[j].transform.GetComponent <GroundController>()._groundType == 99)
{
hitNone = true;
}
else if ((int)hits[j].transform.GetComponent <GroundController>()._groundType == 10)
{
if (hits[j].transform.GetComponent <GroundController>().charaJob != charaJob)
{
if (onProtection != null && !hasOcclusion)
{
onProtection.Invoke(hits[j].transform.GetComponent <GroundController>().charaJob);
}
}
else
{
if (!hitNone)
{
if (isPrev)
{
OnPrevType(hitGcs.ToArray(), isEnd);
}
else
{
int ratio = CalculateRatio(hitGcs.ToArray(), charaJob, isTouchUp, isEnd, isTest);
if (ratio > 0)
{
RaycastData data = new RaycastData();
data.start = GetComponent <GroundController>();
data.end = hits[j].transform.GetComponent <GroundController>();
data.ratio = ratio;
data.hits = new List <GroundController>();
if (charaJob != 0)
{
data.CharaJob = charaJob;
}
for (int h = 0; h < hitGcs.Count - 1; h++)
{
data.hits.Add(hitGcs[h].collider.GetComponent <GroundController>());
}
dataList.Add(data);
hasActived = true;
}
if (j > 0)
{
if (hits[j].collider.GetComponent <GroundController>().isActived)
{
hasActived = true;
}
}
}
}
else
{
}
break;
}
}
}
}
if (!isPrev)
{
OnRaycasted(hasActived, isTouchUp);
}
return(dataList);
}
private void SetDependencies()
{
raycastData = raycastController.Data;
physicsData = physicsController.Data;
layerMaskData = layerMaskController.Data;
}
private void HandleHorizontalCollisions(ref float2 movementDelta, float skinWidth, CollisionData collisionData, RaycastData raycastData)
{
float horizontalDirection = math.sign(movementDelta.x);
float raycastDistance = math.max(math.abs(movementDelta.x) + skinWidth, 2 * skinWidth);
Vector2 raycastOrigin = (horizontalDirection == 1) ? raycastData.BottomRight : raycastData.BottomLeft;
for (int i = 0; i < raycastData.HorizontalRayCount; i++)
{
Vector2 ray = raycastOrigin + (Vector2.up * (raycastData.HorizontalRaySpacing * i));
Debug.DrawRay(ray, Vector2.right * horizontalDirection * raycastDistance, Color.red, 0.1f);
RaycastHit2D hit = Physics2D.Raycast(ray, Vector2.right * horizontalDirection, raycastDistance, collisionData.Mask);
if (hit)
{
if (hit.distance == 0)
{
continue;
}
float slopeAngle = Vector2.Angle(hit.normal, Vector2.up);
if (i == 0 && slopeAngle <= collisionData.MaxSlopeAngle)
{
if (collisionData.decendingSlope)
{
collisionData.decendingSlope = false;
}
float distanceToSlope = 0;
if (slopeAngle != collisionData.previousSlopeAngle)
{
distanceToSlope = hit.distance - skinWidth;
movementDelta.x -= distanceToSlope * horizontalDirection;
}
HandleSlopeAscend(ref movementDelta, slopeAngle, collisionData);
movementDelta.x += distanceToSlope * horizontalDirection;
}
if (!collisionData.ascendingSlope || slopeAngle > collisionData.MaxSlopeAngle)
{
movementDelta.x = (hit.distance - skinWidth) * horizontalDirection;
raycastDistance = hit.distance;
if (collisionData.ascendingSlope)
{
movementDelta.y = math.tan(math.radians(collisionData.slopeAngle)) * math.abs(movementDelta.x);
}
collisionData.Right = (horizontalDirection == 1);
collisionData.Left = (horizontalDirection == -1);
}
}
}
}
protected virtual void DrawMesh()
{
if (!ShouldDrawMesh)
{
return;
}
int steps = Mathf.RoundToInt(MeshDensity * VisionAngle);
float stepsAngle = VisionAngle / steps;
_viewPoints.Clear();
for (int i = 0; i <= steps; i++)
{
float angle = stepsAngle * i + EulerAngles.y - VisionAngle / 2f;
_viewCast = RaycastAtAngle(angle);
if (i > 0)
{
bool thresholdExceeded = Mathf.Abs(_oldViewCast.Distance - _viewCast.Distance) > EdgeThreshold;
if ((_oldViewCast.Hit != _viewCast.Hit) || (_oldViewCast.Hit && _viewCast.Hit && thresholdExceeded))
{
MeshEdgePosition edge = FindMeshEdgePosition(_oldViewCast, _viewCast);
if (edge.PointA != Vector3.zero)
{
_viewPoints.Add(edge.PointA);
}
if (edge.PointB != Vector3.zero)
{
_viewPoints.Add(edge.PointB);
}
}
}
_viewPoints.Add(_viewCast.Point);
_oldViewCast = _viewCast;
}
int numberOfVertices = _viewPoints.Count + 1;
if (numberOfVertices != _numberOfVerticesLastTime)
{
Array.Resize(ref _vertices, numberOfVertices);
Array.Resize(ref _triangles, (numberOfVertices - 2) * 3);
}
_vertices[0].x = 0;
_vertices[0].y = 0;
_vertices[0].z = 0;
for (int i = 0; i < numberOfVertices - 1; i++)
{
_vertices[i + 1] = this.transform.InverseTransformPoint(_viewPoints[i]);
if (i < numberOfVertices - 2)
{
_triangles[i * 3] = 0;
_triangles[i * 3 + 1] = i + 1;
_triangles[i * 3 + 2] = i + 2;
}
}
_visionMesh.Clear();
_visionMesh.vertices = _vertices;
_visionMesh.triangles = _triangles;
_visionMesh.RecalculateNormals();
_numberOfVerticesLastTime = numberOfVertices;
}
public void setRaycastData(RaycastData raycastData)
{
m_raycastData = raycastData;
}
private List <MaskMeshData> RayCast(MaskMeshData.TYPE _type)
{
LayerMask mask;
switch (_type)
{
case MaskMeshData.TYPE.FULL:
mask = m_fullCoverLayerMask;
break;
case MaskMeshData.TYPE.SEMI:
mask = m_semiCoverLayerMask;
break;
default:
throw new ArgumentOutOfRangeException(nameof(_type), _type, null);
}
var meshDataCollection = new List <MaskMeshData>();
var currentMeshData = new MaskMeshData(_type);
var step = m_lineOfSight.m_amplitudeOfSightInDegrees / (m_lineOfSight.m_numberOfRaycast - 1);
for (var i = 0; i < m_lineOfSight.m_numberOfRaycast; i++)
{
var angle = (-m_lineOfSight.m_amplitudeOfSightInDegrees * .5f) + (i * step);
var rayCastDirection = Quaternion.Euler(0, angle, 0) * transform.forward;
var ray = new UnityEngine.Ray(transform.position, rayCastDirection);
var currentRayCastResult = new RaycastData()
{
m_angle = angle,
m_direction = rayCastDirection
};
if (!Physics.Raycast(ray, out var hit, m_lineOfSight.m_maxDistance, mask))
{
currentRayCastResult.m_hit = false;
currentRayCastResult.m_start = transform.position;
currentRayCastResult.m_end = ray.GetPoint(m_lineOfSight.m_maxDistance);
if (m_previousRaycastData.m_hit)
{
if (currentMeshData.m_datas.Count > 0)
{
meshDataCollection.Add(currentMeshData);
}
}
m_previousRaycastData = currentRayCastResult;
continue;
}
currentRayCastResult.m_hit = true;
currentRayCastResult.m_start = hit.point;
currentRayCastResult.m_end = ray.GetPoint(m_lineOfSight.m_maxDistance);
if (m_previousRaycastData.m_hit)
{
currentMeshData.m_datas.Add(currentRayCastResult);
if (i == m_lineOfSight.m_numberOfRaycast - 1)
{
if (currentMeshData.m_datas.Count > 0)
{
meshDataCollection.Add(currentMeshData);
}
}
}
else
{
currentMeshData = new MaskMeshData(_type);
currentMeshData.m_datas.Add(currentRayCastResult);
if (i > 0)
{
FindEdge();
}
}
m_previousRaycastData = currentRayCastResult;
}
return(meshDataCollection);
}
//private NativeArray<RaycastHit> m_result;
// Start is called before the first frame update
void Start()
{
m_previousRaycastData = new RaycastData();
m_meshDataCollection = new List <MaskMeshData>();
}
private void AddRaycastResult(RaycastData _data)
{
m_currentMeshData.m_datas.Add(_data);
}
private void Dependencies()
{
raycastData = GetComponent <RaycastController>().Data;
platformerData = GetComponent <PlatformerController>().Data;
}
private void HandleSlopeDecend(ref float2 movementDelta, float skinWidth, CollisionData collisionData, RaycastData raycastData)
{
float horizontalDirection = math.sign(movementDelta.x);
Vector2 raycastOrigin = (horizontalDirection == 1) ? raycastData.BottomLeft : raycastData.BottomRight;
RaycastHit2D hit = Physics2D.Raycast(raycastOrigin, Vector2.down, Mathf.Infinity, collisionData.Mask);
if (hit)
{
float slopeAngle = Vector2.Angle(hit.normal, Vector2.up);
float radianSlopeAngle = math.radians(slopeAngle);
if (slopeAngle != 0 && slopeAngle <= collisionData.MaxSlopeAngle)
{
if (math.sign(hit.normal.x) == horizontalDirection)
{
float moveDistance = math.abs(movementDelta.x);
if (hit.distance - skinWidth <= math.tan(radianSlopeAngle) * moveDistance)
{
movementDelta.x = math.cos(radianSlopeAngle) * moveDistance * horizontalDirection;
movementDelta.y -= math.sin(radianSlopeAngle) * moveDistance;
collisionData.slopeAngle = slopeAngle;
collisionData.decendingSlope = true;
collisionData.Below = true;
}
}
}
}
}
public static bool Raycast(Vector3 origin, Vector3 direction, out RaycastHit raycastHit, RaycastData raycastData) => Physics.Raycast(
origin: origin,
direction: direction,
hitInfo: out raycastHit,
maxDistance: raycastData._MaxDistance,
layerMask: raycastData._LayerMask,
queryTriggerInteraction: raycastData._QueryTriggerInteraction
);
private RaycastData GetCornerTopRightRaycastData()
{
RaycastData topRightCornerRaycastData = GetDominantCornerAxis(topRightCornerPoint.position, rightDownDirection, leftUpDirection, cornerRayLength);
return(topRightCornerRaycastData);
}
