void WallDisplace(RaycastDirection dir, RaycastPosition pos, Vector3 collisionPt)
{
Vector3 displaceDir = DisplaceDirection(dir).normalized *width;
float posDisplace = DisplacePosition(pos);
transform.position = (collisionPt - (Vector3.up * posDisplace)) - displaceDir;
}
/// <summary>
/// Wallcast function for player with a large collider.
/// Cast out from eight major directions, starting with forward and rotatinf to forward left, from
/// groin region up to head.
/// If collision is found, assign references as needed and stop checking.
/// </summary>
/// <param name="direction">Enum reference for detected collision detection.</param>
/// <param name="position">Enum reference for relative position on player collision was at.</param>
/// <param name="collisionPoint">Vector3 reference for where collision is detected at in the world.</param>
void Wallcast(ref RaycastDirection direction, ref RaycastPosition position, ref Vector3 collisionPoint)
{
Vector3 raycastPos, raycastDir;
/* For the three points on the player, starting from the groin up to the head, cast out starting from
* forward and rotating around clockwise to forward left to determine if there is a collision. */
for (int pos = (int)RaycastPosition.GROIN; pos <= (int)RaycastPosition.HEAD; pos++)
{
for (int dir = (int)RaycastDirection.FORWARD; dir <= (int)RaycastDirection.FORWARD_LEFT; dir++)
{
raycastPos = GetRaycastPosition((RaycastPosition)pos);
raycastDir = GetRaycastDirection((RaycastDirection)dir);
// If a collision is detected, assign the relative point, direction, and collision point in the world
if (Raycast(raycastPos, raycastDir, (RaycastPosition)pos, (RaycastDirection)dir))
{
Debug.Log("Collision Detected");
direction = (RaycastDirection)dir;
position = (RaycastPosition)pos;
collisionPoint = wallHits[8 * pos + dir].point;
}
// Stop looping through directions if a collision was detected
if (direction != RaycastDirection.NULL)
{
break;
}
}
// Stop looping through player positions if a collision was detected
if (direction != RaycastDirection.NULL)
{
break;
}
}
}
void CheckCollisions_Walls()
{
// Wall Raycast direction, player position, and world point
RaycastDirection colliDir = RaycastDirection.NULL;
RaycastPosition colPos = RaycastPosition.GROIN;
Vector3 colPt = Vector3.one * DEFAULT_HIT_DUMMY;
// Check for a wall hit, calling the corresponding function depending on the collider
if (wallHits.Length == SMALL_COLLIDER_WALLCHECKS)
{
Wallcast(ref colliDir, ref colPt); // Check from center
if (colliDir != RaycastDirection.NULL && !TestIncline())
{
Debug.Log("Collision detected in " + GetCollisionDirection(colliDir) + " direction");
WallDisplace(colliDir, colPt);
}
}
else
{
Wallcast(ref colliDir, ref colPos, ref colPt); // Check from groin, center, and head
if (colliDir != RaycastDirection.NULL && !TestIncline())
{
Debug.Log("Collision Detected at " + GetCollisionPosition(colPos) + ", " + GetCollisionDirection(colliDir) + " direction");
WallDisplace(colliDir, colPos, colPt);
}
}
}
float DisplacePosition(RaycastPosition pos)
{
switch (pos)
{
case (RaycastPosition.GROIN):
return(-(height - width));
case (RaycastPosition.HEAD):
return(height - width);
default:
return(0);
}
}
string GetCollisionPosition(RaycastPosition pos)
{
switch (pos)
{
case (RaycastPosition.GROIN):
return("Groin");
case (RaycastPosition.CORE):
return("Core");
case (RaycastPosition.HEAD):
return("Head");
default:
return("Error?");
}
}
/// <summary>
/// Return where on the player to cast out from based on the passed RaycastPosition pos.
/// </summary>
/// <param name="pos">Enum representation of the player position to cast from.</param>
/// <returns>Return the relative player position to cast out from.</returns>
Vector3 GetRaycastPosition(RaycastPosition pos)
{
switch (pos)
{
case (RaycastPosition.GROIN):
if (wallHits.Length == SMALL_COLLIDER_WALLCHECKS)
{
return(transform.position);
}
else
{
return(transform.position - (Vector3.up * (height - width)));
}
case (RaycastPosition.CORE):
return(transform.position);
case (RaycastPosition.HEAD):
return(transform.position + (Vector3.up * (height - width)));
}
return(Vector3.zero);
}
/// <summary>
/// Return if a raycast hit is occuring at raycastPos in raycastDir and assign to wallHits
/// based on position and direction enum values.
/// </summary>
/// <param name="raycastPos">position raycast is being cast from; either head, core, or groin area on player.</param>
/// <param name="raycastDir">Direction from raycastPos to cast from; based on one of eight core directions.</param>
/// <param name="position">Enum representing where from player to raycast from; used for assigning to wallHits</param>
/// <param name="direction">Enum representing which direction to raycast out; used for assigning to wallHits</param>
/// <returns>true if a raycast hit occurs, false if not.</returns>
bool Raycast(Vector3 raycastPos, Vector3 raycastDir, RaycastPosition position, RaycastDirection direction)
{
return(Physics.Raycast(raycastPos, raycastDir, out wallHits[8 * (int)position + (int)direction], width + collisionPadding, groundLayer));
}
void Awake()
{
rayPos = cameraWithRaycast.GetComponent <RaycastPosition>();
}
