string GetCollisionDirection(RaycastDirection dir)
{
switch (dir)
{
case (RaycastDirection.FORWARD):
return("Forward");
case (RaycastDirection.FORWARD_RIGHT):
return("Forward-Right");
case (RaycastDirection.RIGHT):
return("Right");
case (RaycastDirection.BACK_RIGHT):
return("Back-Right");
case (RaycastDirection.BACK):
return("Back");
case (RaycastDirection.BACK_LEFT):
return("Back-Left");
case (RaycastDirection.LEFT):
return("Left");
case (RaycastDirection.FORWARD_LEFT):
return("Forward-Left");
default:
return("Error?");
}
}
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;
}
Vector3 DisplaceDirection(RaycastDirection dir)
{
switch (dir)
{
case (RaycastDirection.FORWARD):
return(forward);
case (RaycastDirection.FORWARD_RIGHT):
return(forwardRight);
case (RaycastDirection.RIGHT):
return(right);
case (RaycastDirection.BACK_RIGHT):
return(backRight);
case (RaycastDirection.BACK):
return(back);
case (RaycastDirection.BACK_LEFT):
return(backLeft);
case (RaycastDirection.LEFT):
return(left);
case (RaycastDirection.FORWARD_LEFT):
return(forwardLeft);
default:
return(Vector3.zero);
}
}
/// <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);
}
}
}
bool RaycastCollideVertical(RaycastDirection direction)
{
Ray floorRay_L, floorRay_R;
if (direction == RaycastDirection.Down)
{
floorRay_L = new Ray(transform.position + floorRayLeftOffset, Vector3.down);
floorRay_R = new Ray(transform.position + floorRayRightOffset, Vector3.down);
}
else if (direction == RaycastDirection.Up)
{
floorRay_L = new Ray(transform.position + floorRayLeftOffset, Vector3.up);
floorRay_R = new Ray(transform.position + floorRayRightOffset, Vector3.up);
}
else
{
Debug.Log("RaycastCollideVertical() BAD DIRECTION");
return(true);
}
RaycastHit floorHit;
if (Physics.Raycast(floorRay_L, out floorHit, this.collider.bounds.extents.y + .1f))
{
if (floorHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Down)
{
transform.position = new Vector3(transform.position.x, floorHit.point.y + this.collider.bounds.extents.y, 0);
}
else if (direction == RaycastDirection.Up)
{
transform.position = new Vector3(transform.position.x, floorHit.point.y - this.collider.bounds.extents.y, 0);
}
return(true);
}
}
else if (Physics.Raycast(floorRay_R, out floorHit, this.collider.bounds.extents.y + .1f))
{
if (floorHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Down)
{
transform.position = new Vector3(transform.position.x, floorHit.point.y + this.collider.bounds.extents.y, 0);
}
else if (direction == RaycastDirection.Up)
{
transform.position = new Vector3(transform.position.x, floorHit.point.y - this.collider.bounds.extents.y, 0);
}
return(true);
}
}
return(false);
}
private float ClosestWallInDirection(RaycastDirection direction, float maxDistance)
{
float result = -1;
Vector3 directionVector = default;
switch (direction)
{
case RaycastDirection.Down:
directionVector = Vector3.down;
break;
case RaycastDirection.Up:
directionVector = Vector3.up;
break;
case RaycastDirection.Left:
directionVector = Vector3.left;
break;
case RaycastDirection.Right:
directionVector = Vector3.right;
break;
}
var colliderHeight = info.ColliderHeight * 0.99f;
var colliderWidth = info.ColliderWidth * 0.99f;
bool indexZero = true;
RaycastHit hit;
for (int i = 0; i < info.RaycastsPrecision; i++)
{
var rayDistance = maxDistance;
Vector3 startShift = default;
if (direction == RaycastDirection.Left || direction == RaycastDirection.Right)
{
var yShift = colliderHeight / 2 - i * colliderHeight / (info.RaycastsPrecision - 1);
startShift = new Vector3(0, yShift, 0);
}
if (direction == RaycastDirection.Up || direction == RaycastDirection.Down)
{
var xShift = colliderWidth / 2 - i * colliderWidth / (info.RaycastsPrecision - 1);
startShift = new Vector3(xShift, 0, 0);
}
if (Physics.Raycast(transform.position + startShift,
directionVector, out hit, rayDistance))
{
if (indexZero || hit.distance < result)
{
result = hit.distance;
indexZero = false;
}
}
}
return(result);
}
// Start is called before the first frame update
void Start()
{
globalData = GameObject.Find("GameManager").GetComponent <GlobalData>();
RaycastDirection raycastDirection = GetComponent <RaycastDirection>();
//Beschreibt den Versatz der "Augen" zum Creature Mittelpunkt
raycastDirection.offsetStartPoint = new Vector3(0, 0, 0.6f);
//Gibt die Richtung der Sensoren vor
raycastDirection.directions.Add(new Vector3(0, -0.25f, 1));
raycastDirection.directions.Add(new Vector3(0, 0, 1));
raycastDirection.directions.Add(new Vector3(-0.5f, 0, 1));
raycastDirection.directions.Add(new Vector3(0.5f, 0, 1));
}
public Vector3 Raycaster(RaycastDirection direction)
{
float xMin = transform.position.x - Collider.bounds.min.x;
float xMax = transform.position.x - Collider.bounds.max.x;
RaycastHit hit;
if (Physics.Raycast(transform.position + new Vector3(xMin, 0, 0), direction.Direction, out hit, direction.Length) ||
Physics.Raycast(transform.position + new Vector3(xMax, 0, 0), direction.Direction, out hit, direction.Length) ||
Physics.Raycast(transform.position, direction.Direction, out hit, direction.Length))
{
return(hit.point - (direction.Direction * direction.Length));
}
return(Vector3.zero);
}
/// <summary>
/// Wallcast function for player with a small collider.
/// Cast out from eight major directions, starting with forward and rotating to forward left, from center.
/// If collision is found, assign references as needed and stop checking.
/// </summary>
/// <param name="direction">Enum reference for detected collision direction. </param>
/// <param name="collisionPoint">Vector3 reference for where collision is detected at in the world.</param>
void Wallcast(ref RaycastDirection direction, ref Vector3 collisionPoint)
{
Vector3 raycastDir;
// Cast out from the center of the player, rotating clockwise from forward to forward left, to determine if there is a collision.
for (int dir = (int)RaycastDirection.FORWARD; dir <= (int)RaycastDirection.FORWARD_LEFT; dir++)
{
raycastDir = GetRaycastDirection((RaycastDirection)dir);
// If a collision is detected, assign the direction and collision point in the world.
if (Raycast(transform.position, raycastDir, RaycastPosition.GROIN, (RaycastDirection)dir))
{
direction = (RaycastDirection)dir;
collisionPoint = wallHits[dir].point;
}
// Stop looping through directions if a collision was detected
if (direction != RaycastDirection.NULL)
{
break;
}
}
}
bool RaycastCollideHorizontal(RaycastDirection direction)
{
Ray wallRay_T, wallRay_B, wallRay_M;
if (direction == RaycastDirection.Right)
{
wallRay_T = new Ray(transform.position + wallRayTopOffset, Vector3.right);
wallRay_M = new Ray(transform.position, Vector3.right);
wallRay_B = new Ray(transform.position + wallRayBottomOffset, Vector3.right);
}
else if (direction == RaycastDirection.Left)
{
wallRay_T = new Ray(transform.position + wallRayTopOffset, Vector3.left);
wallRay_M = new Ray(transform.position, Vector3.left);
wallRay_B = new Ray(transform.position + wallRayBottomOffset, Vector3.left);
}
else
{
Debug.Log("RaycastCollideHorizontal() BAD DIRECTION");
return(true);
}
RaycastHit wallHit;
if (Physics.Raycast(wallRay_T, out wallHit, collider.bounds.extents.x + .1f))
{
if (wallHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Right)
{
transform.position = new Vector3(wallHit.point.x - collider.bounds.extents.x, transform.position.y, 0);
}
else if (direction == RaycastDirection.Left)
{
transform.position = new Vector3(wallHit.point.x + collider.bounds.extents.x, transform.position.y, 0);
}
return(true);
}
}
else if (Physics.Raycast(wallRay_M, out wallHit, collider.bounds.extents.x + .1f))
{
if (wallHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Right)
{
transform.position = new Vector3(wallHit.point.x - collider.bounds.extents.x, transform.position.y, 0);
}
else if (direction == RaycastDirection.Left)
{
transform.position = new Vector3(wallHit.point.x + collider.bounds.extents.x, transform.position.y, 0);
}
return(true);
}
}
else if (Physics.Raycast(wallRay_B, out wallHit, collider.bounds.extents.x + .1f))
{
if (wallHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Right)
{
transform.position = new Vector3(wallHit.point.x - collider.bounds.extents.x, transform.position.y, 0);
}
else if (direction == RaycastDirection.Left)
{
transform.position = new Vector3(wallHit.point.x + collider.bounds.extents.x, transform.position.y, 0);
}
return(true);
}
}
return(false);
}
bool RaycastCollideVertical(RaycastDirection direction)
{
Ray floorRay_L, floorRay_R;
if (direction == RaycastDirection.Down)
{
floorRay_L = new Ray(transform.position + floorRayLeftOffset, Vector3.down);
floorRay_R = new Ray(transform.position + floorRayRightOffset, Vector3.down);
}
else if (direction == RaycastDirection.Up)
{
floorRay_L = new Ray(transform.position + floorRayLeftOffset, Vector3.up);
floorRay_R = new Ray(transform.position + floorRayRightOffset, Vector3.up);
}
else
{
Debug.Log("RaycastCollideVertical() BAD DIRECTION");
return true;
}
RaycastHit floorHit;
if (Physics.Raycast(floorRay_L, out floorHit, this.collider.bounds.extents.y + .1f))
{
if (floorHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Down)
transform.position = new Vector3(transform.position.x, floorHit.point.y + this.collider.bounds.extents.y, 0);
else if (direction == RaycastDirection.Up)
transform.position = new Vector3(transform.position.x, floorHit.point.y - this.collider.bounds.extents.y, 0);
return true;
}
}
else if (Physics.Raycast(floorRay_R, out floorHit, this.collider.bounds.extents.y + .1f))
{
if (floorHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Down)
transform.position = new Vector3(transform.position.x, floorHit.point.y + this.collider.bounds.extents.y, 0);
else if (direction == RaycastDirection.Up)
transform.position = new Vector3(transform.position.x, floorHit.point.y - this.collider.bounds.extents.y, 0);
return true;
}
}
return false;
}
bool RaycastCollideHorizontal(RaycastDirection direction)
{
Ray wallRay_T, wallRay_B, wallRay_M;
if (direction == RaycastDirection.Right)
{
wallRay_T = new Ray(transform.position + wallRayTopOffset, Vector3.right);
wallRay_M = new Ray(transform.position, Vector3.right);
wallRay_B = new Ray(transform.position + wallRayBottomOffset, Vector3.right);
}
else if (direction == RaycastDirection.Left)
{
wallRay_T = new Ray(transform.position + wallRayTopOffset, Vector3.left);
wallRay_M = new Ray(transform.position, Vector3.left);
wallRay_B = new Ray(transform.position + wallRayBottomOffset, Vector3.left);
}
else
{
Debug.Log("RaycastCollideHorizontal() BAD DIRECTION");
return true;
}
RaycastHit wallHit;
if (Physics.Raycast(wallRay_T, out wallHit, collider.bounds.extents.x + .1f))
{
if (wallHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Right)
transform.position = new Vector3(wallHit.point.x - collider.bounds.extents.x, transform.position.y, 0);
else if (direction == RaycastDirection.Left)
transform.position = new Vector3(wallHit.point.x + collider.bounds.extents.x, transform.position.y, 0);
return true;
}
}
else if (Physics.Raycast(wallRay_M, out wallHit, collider.bounds.extents.x + .1f))
{
if (wallHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Right)
transform.position = new Vector3(wallHit.point.x - collider.bounds.extents.x, transform.position.y, 0);
else if (direction == RaycastDirection.Left)
transform.position = new Vector3(wallHit.point.x + collider.bounds.extents.x, transform.position.y, 0);
return true;
}
}
else if (Physics.Raycast(wallRay_B, out wallHit, collider.bounds.extents.x + .1f))
{
if (wallHit.collider.gameObject.CompareTag("Solid"))
{
if (direction == RaycastDirection.Right)
transform.position = new Vector3(wallHit.point.x - collider.bounds.extents.x, transform.position.y, 0);
else if (direction == RaycastDirection.Left)
transform.position = new Vector3(wallHit.point.x + collider.bounds.extents.x, transform.position.y, 0);
return true;
}
}
return false;
}
void WallDisplace(RaycastDirection dir, Vector3 collisionPt)
{
Vector3 displaceDir = DisplaceDirection(dir);
}
/// <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));
}
