//bool rotateBasedOnCamera = false;
void Rotate(StateManager sm)
{
if (cameraTransform.value == null)
{
return;
}
//keep track fo previous rotation in case we need to revert back to it, in the the case of detecting an unclimbable surface
prevRotation = states.mTransform.rotation;
float h = states.movementVariables.horizontal;
float v = states.movementVariables.vertical;
//Get the angle between the camera's forward and the climb's up and get it in 360 degrees
Vector3 camForward = cameraTransform.value.forward;
Vector3 camRight = cameraTransform.value.right;
camForward.y = 0;
camForward.Normalize();
camRight.y = 0;
camRight.Normalize();
float rotateAngle = -Vector3.Angle(climbUp, camForward);
rotateAngle = (Vector3.Angle(climbRight, camForward) > 90f) ? 360f - rotateAngle : rotateAngle;
//rotating climb up and climb right based on camera's position
Vector3 climbForwardAlt = climbForward;
Vector3 climbRightAlt = climbRight;
//float sAngle = Vector3.SignedAngle(climbRight, camForward, Vector3.up);
//climbRightAlt = (sAngle <= 45f || sAngle >= 135f) ? climbRight : - climbRight;
//Debug.Log("ANGLE: " + Vector3.Angle(climbRight, camForward) + " || SIGNED ANGLE: " + Vector3.SignedAngle(climbRight, camForward, Vector3.up));
//if (rotateBasedOnCamera)
//{
// climbForwardAlt = (Quaternion.AngleAxis(rotateAngle, climbUp) * -climbForward);
// climbRightAlt = (Quaternion.AngleAxis(rotateAngle, climbUp) * -climbRight);
// if(climbForwardAlt == Vector3.zero)
// climbForwardAlt = climbForward;
// if (climbRightAlt == Vector3.zero)
// climbRightAlt = climbRight;
//}
//Debug.DrawRay(states.mTransform.position, climbForwardAlt * 5f, Color.magenta);
//Debug.DrawRay(states.mTransform.position, climbRightAlt * 5f, Color.cyan);
Vector3 targetDir = climbForwardAlt * v;
targetDir += (climbRightAlt * h);
targetDir.Normalize();
//Debug.DrawRay(states.transform.position, targetDir * 5, Color.magenta);
//Debug purposes to visualize the direction
//Debug.DrawRay(states.transform.position, climbForwardAlt * 3, Color.red);
//Debug.DrawRay(states.transform.position, climbRightAlt * 3, Color.yellow);
//If there's no input, then don't do anything
if (targetDir == Vector3.zero)
{
return;
}
//Apply rotation
states.movementVariables.moveDirection = targetDir;
//rotationSpeed = Mathf.Lerp(20, 6, (states.rigid.velocity.magnitude / 6f));
Quaternion tr = Quaternion.LookRotation(targetDir, states.transform.up);
tRotation = Quaternion.Slerp(states.mTransform.rotation, tr, Time.deltaTime * states.movementVariables.moveAmount * states.climbingVariables.turnSpeed);
//Quaternion targetRotation = Quaternion.Slerp(states.mTransform.rotation, tr, states.delta * states.movementVariables.moveAmount * rotationSpeed);
//Vector3 underOrigin = states.transform.position;
//underOrigin += (targetRotation * Vector3.forward) + (states.transform.up * 0.5f);
//// Dir represents the downward direction
//Vector3 dir = (states.transform.position + states.transform.forward + (-states.transform.up * 1.5f)) - underOrigin;
//RaycastHit hit = new RaycastHit();
//Debug.DrawRay(underOrigin, dir, Color.magenta);
//if (Physics.Raycast(underOrigin, dir.normalized, out hit, 1.5f, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
//{
// if (hit.transform.tag == "Climb")
// states.mTransform.rotation = targetRotation;
//}
}
public override void Execute(StateManager sm)
{
}
void CheckRaycast(StateManager sm)
{
float topFloat = .4f;
Vector3 frontOrigin = states.transform.position + (states.transform.forward * 1.5f) + (states.transform.up * topFloat);
//Debug.DrawRay(frontOrigin, states.transform.forward * 0.75f, Color.blue);
//Raycast in front of the squirrel, used to check if we've hit a ceiling, ground, or another climb-able surface
if (Physics.Raycast(frontOrigin, states.transform.forward, out front, 0.75f, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
{
frontHit = true;
float angle = Vector3.Angle(front.normal, Vector3.up);
//front has hit a new climb that means the change is a big one, no need to check the angle
if (front.transform.tag == "Climb")
{
ignoreGravity = true;
prevAngle = Vector3.Angle(front.normal, states.climbHit.normal);
states.rigid.velocity = Vector3.zero;
//Debug.Log("Front are you f*****g things up, do I have to fix you?");
//SetCameraAngle(states.climbHit.normal, -front.normal);
states.climbHit = front;
startPos = states.transform.position;
targetPos = states.climbHit.point + (states.climbHit.normal * states.climbingVariables.offsetFromWall);
targetRot = Quaternion.FromToRotation(states.transform.up, states.climbHit.normal) * states.transform.rotation;
tVelocity = Vector3.zero;
tRotation = targetRot;
t = 0;
inPos = false;
inRot = false;
transitioning = true;
safeTurn = true;
//Debug.Log("Transitiong");
lagDashCooldown = states.lagDashCooldown;
// 9/2/20: Acute corner transfer best value - 1.15f
// Animation speed - .75f
states.climbingVariables.transferSpeedMult = 1.15f;
states.anim.CrossFade(states.hashes.squ_climb_corner_acute, 0.2f);
SafeClimb();
return;
}
else
{
if (angle < 70)
{
//Debug.LogError("Front has detected non-climbable surface, exit the climb");
states.rigid.velocity = Vector3.zero;
states.climbHit = front;
states.anim.CrossFade(states.hashes.squ_climb_corner_acute, 0.2f);
states.climbState = PlayerManager.ClimbState.EXITING;
states.climbingVariables.transferSpeedMult = 1.5f;
return;
}
else
{
//Debug.Log("Front has detected a wall that blocks the user and isn't climbable");
states.rigid.velocity = Vector3.zero;
}
}
}
else
{
frontHit = false;
}
Vector3 underOrigin = states.transform.position;
underOrigin += states.transform.forward * 1.7f + (states.transform.up * 0.5f);
// Dir represents the downward direction
Vector3 dir = -states.transform.forward + (-states.transform.up);
// Draw the rays
//Debug.DrawRay(underOrigin, dir * 1.5f, Color.green);
//Debug.DrawRay(underOrigin, Quaternion.AngleAxis(30f, states.climbHit.normal) * dir * 1.5f, Color.red);
//Debug.DrawRay(underOrigin, Quaternion.AngleAxis(-30f, states.climbHit.normal) * dir * 1.5f, Color.blue);
if (Physics.Raycast(underOrigin, dir, out under, 1.5f, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
{
//underside has hit something
underHit = true;
float angle = Vector3.Angle(under.normal, Vector3.up);
//If I hit another climb, check if I should transfer to it
if (under.transform.tag == "Climb")
{
UnderHit();
}
//I didn't hit a climb but I must do something based on the angle of the hit
else
{
//detach
if (angle < 70)
{
//Debug.LogError("Under has detected non-climbable surface, exit the climb");
states.climbHit = under;
states.climbState = PlayerManager.ClimbState.EXITING;
states.anim.CrossFade(states.hashes.squ_climb_corner, 0.2f);
states.anim.SetBool(states.hashes.isClimbing, false);
states.rigid.velocity = Vector3.zero;
states.climbingVariables.transferSpeedMult = 1.5f;
return;
}
////detach
//else if (angle > 90)
//{
// Debug.Log("Under has detected a wall that blocks the user and isn't climbable");
// states.climbState = PlayerManager.ClimbState.NONE;
// states.isJumping = true;
// states.anim.SetBool(states.hashes.isClimbing, false);
// return;
//}
//stop moving
else
{
//Debug.Log("Under has detected a non-climbable surface, stop moving");
//states.rigid.velocity = -states.rigid.velocity;
//states.rigid.velocity = Vector3.zero;
//states.transform.rotation = prevRotation;
return;
}
}
}
else
{
if (Physics.Raycast(underOrigin, Quaternion.AngleAxis(30f, states.climbHit.normal) * dir, out under, 1.5f, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
{
if (under.transform.tag == "Climb")
{
UnderHit();
}
}
else if (Physics.Raycast(underOrigin, Quaternion.AngleAxis(-30f, states.climbHit.normal) * dir, out under, 1.5f, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
{
if (under.transform.tag == "Climb")
{
UnderHit();
}
}
else
{
underHit = false;
states.rigid.velocity = Vector3.zero;
//Debug.LogError("Under isn't hitting anything");
states.climbState = PlayerManager.ClimbState.NONE;
states.isJumping = true;
states.anim.SetBool(states.hashes.isClimbing, false);
}
}
}
public void Set(StateManager s)
{
value = s;
}
public override bool CheckCondition(StateManager sm)
{
PlayerManager state = (PlayerManager)sm;
return(state.climbState == PlayerManager.ClimbState.EXITING);
}
public override bool CheckCondition(StateManager sm)
{
PlayerManager state = (PlayerManager)sm;
return(!state.newDashActive && state.isGrounded);
}
public override bool CheckCondition(StateManager sm)
{
EnemyManager state = (EnemyManager)sm;
return(state.state == EnemyManager.DetectState.DETECTED);
}
public override bool CheckCondition(StateManager sm)
{
PlayerManager state = (PlayerManager)sm;
return(!state.dashActive && state.climbState != PlayerManager.ClimbState.NONE);
}
public override void Execute(StateManager sm)
{
PlayerManager states = (PlayerManager)sm;
ground = states.GetRotationNormal();
//Vector3 origin = states.transform.position + (states.transform.up * 0.2f) + (states.transform.forward * 1.75f);
//RaycastHit hit = new RaycastHit();
//Vector3 dir = SlidePlayer.ProjectVectorOnPlane(Vector3.up, states.transform.forward);
//Debug.DrawRay(origin, dir * 0.5f, Color.blue);
////Raycast in front of the squirrel, used to check if we've hit a ceiling, ground, or another climb-able surface
//if (Physics.SphereCast(origin, 0.2f, states.transform.forward, out hit, 0.5f, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
//{
// ground = (hit.normal + ground).normalized;
// Debug.DrawRay(hit.point, hit.normal, Color.black);
//}
////If the front raycast hasn't hit anything then do another raycast
////Otherwise just use the front normal
//if (states.front == null)
//{
// //This raycast goes out the back and points diagonally behnd the player
// //If this hits something then use that as the ground unless it hit a wall
// Vector3 origin = states.transform.position;
// origin += states.transform.up * 0.35f;
// RaycastHit hit;
// bool didHit;
// Vector3 dir = -states.transform.forward - states.transform.up;
// Debug.DrawRay(origin, dir * 0.6f, Color.green);
// didHit = Physics.Raycast(origin, dir, out hit, 0.6f, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore);
// if (didHit)
// {
// float backAngle = Vector3.Angle(hit.normal, Vector3.up);
// if (backAngle >= 70)
// didHit = false;
// else
// ground = hit.normal;
// }
// if (!didHit)
// {
// ground = states.groundNormal;
// }
//}
//else
// ground = states.frontNormal;
float angle = Vector3.Angle(ground, Vector3.up);
float angle2 = Vector3.Angle(states.mTransform.up, Vector3.up);
//Debug.Log("angle 2 - " + angle2);
// QUATERNION WAY
float amount = 15;
var test = states.GetComponent <Animation>();
if (states.rotateFast && !states.anim.GetBool(states.hashes.isLanding))
{
bool quickLand = states.anim.GetBool(states.hashes.QuickLand);
if (!quickLand)
{
amount = 30;
}
//else
// amount = 15;
}
if (angle < rotationConstraint)
{
Quaternion tr = Quaternion.FromToRotation(states.mTransform.up, ground) * states.mTransform.rotation;
Quaternion targetRotation = Quaternion.Slerp(states.mTransform.rotation, tr, states.delta * amount);
states.mTransform.rotation = targetRotation;
}
if (Mathf.Abs((angle2 - angle)) < 1.0f)
{
states.anim.SetBool(states.hashes.QuickLand, false);
}
// NON-Quaternion way
/*Vector3 newAxis = Vector3.Cross(states.mTransform.up, states.groundNormal);
* float angle3 = Vector3.Angle(states.mTransform.up, states.groundNormal);
* states.mTransform.RotateAround(states.mTransform.position, newAxis, angle3);*/
}
public override void Execute(StateManager sm)
{
PlayerManager states = (PlayerManager)sm;
states.anim.SetBool(states.hashes.waitForAnimation, status);
}
public override bool CheckCondition(StateManager sm)
{
PlayerManager state = (PlayerManager)sm;
// get ammt of time since jump/leaving ground
float timeDifference = Time.realtimeSinceStartup - state.timeSinceJump;
/*if (state.isGrounded)
* Debug.Log(timeDifference);*/
// have to have been ungrounded to start checking
if (timeDifference > .35f)
{
bool result = state.isGrounded;
/*bool test2 = state.anim.GetBool(state.hashes.inDaFall);
*
* bool result = false;
*
* if (test && !test2)
* result = true;*/
// if grounded, then land
if (result)
{
bool inMeat = false;
if (state.front != null)
{
inMeat = (state.front.name == "BenchMeat");
}
if (state.middle != null)
{
inMeat = (state.middle.name == "BenchMeat");
}
if (state.back != null)
{
inMeat = (state.back.name == "BenchMeat");
}
//If been in air for at least a certain amt of time, do the long land anim
if (timeDifference > .65f && !inMeat)
{
state.anim.CrossFade(state.hashes.Land, .2f);
Debug.Log("Landing with the land animation!");
}
//If not, quick land
else
{
state.anim.SetBool(state.hashes.QuickLand, true);
}
}
return(result);
}
else
{
return(false);
}
}
public override void Execute(StateManager sm)
{
PlayerManager states = (PlayerManager)sm;
float frontY = 0;
RaycastHit hit;
RaycastHit hit2;
Vector3 origin = states.mTransform.position + (states.mTransform.forward * frontRayOffset);
Vector3 origin2 = states.mTransform.position;
origin.y += .5f;
origin2.y += .5f;
Vector3 testOrigin = states.mTransform.position + (states.mTransform.forward * .75f);
testOrigin.y += .5f;
RaycastHit testHit;
//Debug.DrawRay(origin2, -Vector3.up, Color.red);
Vector3 targetVelocity = states.mTransform.forward * states.movementVariables.moveAmount * movementSpeed * states.groundSpeedMult;
Vector3 dir = -Vector3.up;
// If player is on a sloped surface, must account for the normal
dir.z = dir.z - states.groundNormal.z;
//Debug.DrawRay(origin, dir, Color.red);
//Debug.DrawRay(origin2, dir, Color.cyan);
// Raycast from first origin point
if (Physics.Raycast(origin, dir, out hit, 1, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
{
// Store y position of hit point
float y = hit.point.y;
// Set StateManager ground normal to be normal of hit
if (Vector3.Angle(hit.normal, Vector3.up) <= 35)
{
states.groundNormal = hit.normal;
states.backupGroundNormal = hit.normal;
}
else
{
states.backupGroundNormal = hit.normal;
}
if (Physics.Raycast(testOrigin, dir, out testHit, 1, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
{
}
// Set frontY to hit point y pos - player's y pos
//WHY?
frontY = y - states.mTransform.position.y;
// Second Raycast from second origin point
if (Physics.Raycast(origin2, dir, out hit2, 1, Layers.ignoreLayersController, QueryTriggerInteraction.Ignore))
{
// If front hit is on a different ground than second hit, most likeley moving between two different grounds
// If so, shouldn't rotate quickly
if (hit.normal != hit2.normal)
{
states.rotateFast = false;
}
else
{
states.rotateFast = true;
}
}
// Trying to address the problem of player "landing" too high up, and then slowly sinking into the slope
//Debug.Log("hit 1 distance - " + hit.distance);
//Debug.Log("hit 2 distance - " + hit2.distance);
// If either of the two raycast hits are too far down
if (hit.distance > .54f || hit2.distance > .54f)
{
//targetVelocity.y -= 45f;
// Set player's position slighly down and then move towards it
var test = states.rigid.position;
test.y -= .05f;
states.rigid.MovePosition(test);
}
}
Vector3 currentVelocity = states.rigid.velocity;
// If grounded
if (states.isGrounded)
{
// Get move amount from movement variables
float moveAmount = states.movementVariables.moveAmount;
// If at least 0.1f movement
if (moveAmount > 0.1f)
{
// Set drag to 0 while moving
states.rigid.drag = 0;
// If player is on a slope
if (Mathf.Abs(frontY) > 0.02f)
{
//targetVelocity.y = ((frontY > 0) ? 1 : -1) * movementSpeed;
//targetVelocity.y = frontY * movementSpeed;
// Set y for target vel
// If frontY is positive (upward slope) then add .2f to the velocity
// If frontY is negative (downward slope) then don't do anything
//targetVelocity.y = ((frontY > 0) ? frontY + 0.2f : frontY) * movementSpeed;
//// If targetVelocity.y is greater than 0, then set it to 0
//// TODO: These two sections seem to cancel each other out
//// This cancels out the extra jump you could get off of slopes
//if (targetVelocity.y > 0)
//{
// targetVelocity.y = 0;
//}
}
}
// If not moving at least 0.1f
else
{
// Get abs of frontY
float abs = Mathf.Abs(frontY);
// If player is on any slope
if (abs > 0.02f && states.slideMomentum.magnitude < 0.25f)
{
//states.rigid.isKinematic = false;
// Stop moving and increase drag so that player doesn't slide while idling
// TODO: check what lower drag values work instead of 4000. Probably is too high.
//targetVelocity.y = 0;
states.rigid.drag = 4000;
}
}
}
else
{
states.rigid.isKinematic = false;
states.rigid.drag = 0;
targetVelocity.y = currentVelocity.y;
}
#region Step up stuff
// If step up is true
// Right now, moves y position up slightly
if (states.stepUp)
{
bool positive = false;
var test = states.rigid.position;
//var test = states.mTransform.forward.z;
if (test.z > 0)
{
positive = true;
}
//Debug.Log(states.mTransform.forward.z);
/*if (positive)
* test.z += .2f;
* else
* test.z -= -.2f;*/
test.y = test.y + .25f;
states.rigid.position = Vector3.Lerp(states.rigid.position, test + (states.mTransform.forward / 4), states.delta * 10);
//states.rigid.velocity = new Vector3(states.rigid.velocity.x, 0, states.rigid.velocity.z);
//targetVelocity.y += 1f;
//states.rigid.AddRelativeForce(0, 10f, 0);
//targetVelocity.y += 1;
//holdYVel = targetVelocity.y;
}
// Step up Jump testing
if (states.stepUpJump)
{
bool positive = false;
var test = states.rigid.position;
//var test = states.mTransform.forward.z;
if (test.z > 0)
{
positive = true;
}
//Debug.Log(states.mTransform.forward.z);
/*if (positive)
* test.z += .2f;
* else
* test.z -= -.1f;*/
test.y = test.y + .1f;
//states.rigid.position = Vector3.Lerp(states.rigid.position, test, states.delta * 20);
//targetVelocity.y += 1f;
//states.rigid.AddRelativeForce(0, 10f, 0);
//targetVelocity.y += 1;
//holdYVel = targetVelocity.y;
}
#endregion
//(Just for moving quickly in Debug - NOT how it will be done later in game)
//if (states.isRun)
//{
// targetVelocity = targetVelocity * 5;
//}
states.targetVelocity = targetVelocity;
states.rigid.velocity = Vector3.Lerp(currentVelocity, targetVelocity + states.slideMomentum, states.delta * movementTime);
//Debug.Log(states.rigid.velocity);
}