public static ProjectVectorOnPlane ( Vector3 planeNormal, Vector3 vector ) : Vector3 | ||
planeNormal | Vector3 | |
vector | Vector3 | |
return | Vector3 |
public bool HeavyDamage(int damage, Vector3 origin) { if (status.Invincible()) { return(false); } if (StateCompare(MarioStates.Knockback) || StateCompare(MarioStates.KnockbackForwards) || StateCompare(MarioStates.TeleportIn) || StateCompare(MarioStates.TeleportOut)) { return(false); } Vector3 direction = Math3d.ProjectVectorOnPlane(controller.up, origin - transform.position).normalized; if (direction == Vector3.zero) { direction = lookDirection; } bool forward = Vector3.Angle(direction, lookDirection) < 90; if (Airborn()) { if (forward) { moveSpeed = -3.0f; currentState = MarioStates.AirKnockback; } else { moveSpeed = 3.0f; currentState = MarioStates.AirKnockbackForwards; } } else { if (forward) { currentState = MarioStates.Knockback; moveSpeed = -3.0f; } else { currentState = MarioStates.KnockbackForwards; moveSpeed = 3.0f; } } lookDirection = forward ? direction : -direction; SmartCamera.Shake(1.6f, 25.0f, 0.5f); sound.PlayTakeDamage(); Instantiate(TakeDamageEffect, transform.position + controller.up * controller.height * 0.6f, Quaternion.identity); status.TakeDamage(damage); return(true); }
// Update is called once per frame void Update() { Vector3 direction = Math3d.ProjectVectorOnPlane(transform.up, (target.position - transform.position).normalized); if (Vector3.Distance(target.position, transform.position) < SightDistance && Vector3.Angle(direction, transform.forward) > SightAngle) { transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.LookRotation(direction), TurnSpeed * Time.deltaTime); if (!AnimatedMesh.GetComponent <Animation>().IsPlaying("turn")) { AnimatedMesh.GetComponent <Animation>().Play("turn"); GetComponent <AudioSource>().Play(); } } else { if (!AnimatedMesh.GetComponent <Animation>().isPlaying) { AnimatedMesh.GetComponent <Animation>().Play("idle"); } } windRotation = SuperMath.ClampAngle(windRotation + 360.0f * Time.deltaTime); WindTransform.Rotation = Quaternion.Euler(new Vector3(0, 0, windRotation)); }
void Wander_SuperUpdate() { if (!IsGrounded(0.5f, true)) { currentState = BobOmbStates.Fall; return; } Vector3 direction = target.position - transform.position; direction = Math3d.ProjectVectorOnPlane(controller.up, direction); float distance = Vector3.Distance(target.position, transform.position); if (Vector3.Angle(direction, lookDirection) < FieldOfView && distance < SightDistance) { currentState = BobOmbStates.Chase; return; } moveSpeed = Mathf.MoveTowards(moveSpeed, WanderSpeed, 3.0f * Time.deltaTime); lookDirection = Quaternion.AngleAxis(30.0f * Time.deltaTime, controller.up) * lookDirection; moveDirection = moveSpeed * lookDirection; }
private float WallCollisionAngle(Vector3 wallNormal, Vector3 direction) { Vector3 planarDirection = Math3d.ProjectVectorOnPlane(controller.up, direction); Vector3 planarWall = Math3d.ProjectVectorOnPlane(controller.up, wallNormal); return(Vector3.Angle(planarWall, planarDirection)); }
/// <summary> /// Provides raycast data based on where a SphereCast would contact the specified normal /// Raycasting downwards from a point along the controller's bottom sphere, based on the provided /// normal /// </summary> /// <param name="groundNormal">Normal of a triangle assumed to be directly below the controller</param> /// <param name="hit">Simulated SphereCast data</param> /// <returns>True if the raycast is successful</returns> private bool SimulateSphereCast(Vector3 groundNormal, out RaycastHit hit) { var groundAngle = Vector3.Angle(groundNormal, up) * Mathf.Deg2Rad; var secondaryOrigin = transform.position + up * Tolerance; if (!Mathf.Approximately(groundAngle, 0)) { var horizontal = Mathf.Sin(groundAngle) * radius; var vertical = (1.0f - Mathf.Cos(groundAngle)) * radius; // Retrieve a vector pointing up the slope var r2 = Vector3.Cross(groundNormal, down); var v2 = -Vector3.Cross(r2, groundNormal); secondaryOrigin += Math3d.ProjectVectorOnPlane(up, v2).normalized *horizontal + up * vertical; } if (Physics.Raycast(secondaryOrigin, down, out hit, Mathf.Infinity, Walkable)) { // Remove the tolerance from the distance travelled hit.distance -= Tolerance; return(true); } return(false); }
public void SetTargetWithAngle(Vector3 point, float angle) { currentRadian = angle * Mathf.Deg2Rad; targetPoint = point; //GizmosHelper.DrawBox(point, Vector3.one * 0.2f, Color.yellow); Vector3 direction = point - firePoint.position; //if (Vector3.Angle(direction, transform.forward) > 10) //{ // // Haven't face the right direction. // projectileArc.gameObject.SetActive(false); // return; //} //else //{ // projectileArc.gameObject.SetActive(true); //} float yOffset = direction.y; direction = Math3d.ProjectVectorOnPlane(Vector3.up, direction); float distance = direction.magnitude; currentSpeed = ProjectileMath.CalculateLaunchSpeed(distance, yOffset, Physics.gravity.magnitude, angle * Mathf.Deg2Rad); projectileArc.UpdateArc(currentSpeed, distance, Physics.gravity.magnitude, currentRadian, direction, true); SetThrowPoint(direction, currentRadian * Mathf.Rad2Deg); }
void Fall_SuperUpdate() { if (AcquiringGround()) { moveDirection = Math3d.ProjectVectorOnPlane(controller.up, moveDirection); currentState = PlayerStates.Idle; return; } if (input.Current.JumpInput && doubleJump == false) { currentState = PlayerStates.DoubleJump; return; } if (input.Current.JumpInput && doubleJump == true) { currentState = PlayerStates.Glide; return; } Vector3 planarMoveDirection = Math3d.ProjectVectorOnPlane(controller.up, moveDirection); Vector3 verticalMoveDirection = moveDirection - planarMoveDirection; planarMoveDirection = Vector3.MoveTowards(planarMoveDirection, LocalMovement() * WalkSpeed, JumpAcceleration * controller.deltaTime); verticalMoveDirection -= controller.up * Gravity * controller.deltaTime; verticalMoveDirection.y = Mathf.Max(verticalMoveDirection.y, -7f); moveDirection = planarMoveDirection + verticalMoveDirection; }
private bool GoldBodySlam() { float radius = controller.radius * 1.5f; Collider[] colliders = Physics.OverlapSphere(transform.position + controller.up * controller.height * 0.5f, radius); foreach (var col in colliders) { EnemyMachine machine = col.GetComponent <EnemyMachine>(); if (machine != null) { if (machine.GetStruck(Math3d.ProjectVectorOnPlane(controller.up, machine.transform.position - transform.position).normalized, 7.0f, 15.0f)) { sound.PlayImpact(); machine.MakeGold(); } } RollingBallGoldDestroy ball = col.GetComponent <RollingBallGoldDestroy>(); if (ball) { ball.BlowUp(); } } return(false); }
/* * Provides raycast data based on where a SphereCast would have contacted * the specified normal. * Raycasting downwards from a point along the controller's bottom sphere, * based on the provided normal. */ private bool SimulateSphereCast(CollisionSphere collisionSphere, Vector3 groundNormal, out RaycastHit hit) { float groundAngle = Vector3.Angle(groundNormal, playerView.Up) * Mathf.Deg2Rad; Vector3 secondaryOrigin = playerView.Position + (playerView.Up * settings.tolerance); if (!Mathf.Approximately(groundAngle, 0)) { float horizontal = Mathf.Sin(groundAngle) * collisionSphere.Radius; float vertical = (1f - Mathf.Cos(groundAngle)) * collisionSphere.Radius; Vector3 upslopeDirection = -CollisionMath.DownslopeDirection(groundNormal, playerView.Down); Vector3 horizontalDirection = Math3d.ProjectVectorOnPlane(playerView.Up, upslopeDirection).normalized; secondaryOrigin += horizontalDirection * horizontal + playerView.Up * vertical; } if (SphereCast(secondaryOrigin, settings.epsilon, playerView.Down, out hit)) { hit.distance -= settings.tolerance; return(true); } return(false); }
bool SlopeLimit() { //Calculate the angle with the current ground first to see if it is greater than slope limit Vector3 n = _currentGround.normal; float a = Vector3.Angle(n, transform.up); if (a > slopeLimit) { //Grab the direction that the controller is moving in Vector3 absoluteMoveDirection = Math3d.ProjectVectorOnPlane(n, transform.position - initialPosition); // Retrieve a vector pointing down the slope Vector3 r = Vector3.Cross(n, -transform.up); Vector3 v = Vector3.Cross(r, n); //Check the angle between the move direction of the controller and a vector down the slope. If less than 90 degrees then the player is moving down the slope return false float angle = Vector3.Angle(absoluteMoveDirection, v); if (angle <= 90.0f) { return(false); } // Calculate where to place the controller on the slope, or at the bottom, based on the desired movement distance Vector3 resolvedPosition = Math3d.ProjectPointOnLine(initialPosition, r, transform.position); Vector3 direction = Math3d.ProjectVectorOnPlane(n, resolvedPosition - transform.position); transform.position += direction; return(true); } return(false); }
void WallSlide_SuperUpdate() { if (input.Current.MoveInput == Vector3.zero || Vector3.Dot(collisionVector, LocalMovement()) > 0) { currentState = PlayerStates.Fall; return; } Vector3 planarMoveDirection = Math3d.ProjectVectorOnPlane(controller.up, moveDirection); Vector3 verticalMoveDirection = moveDirection - planarMoveDirection; if (Vector3.Angle(verticalMoveDirection, controller.up) > 90 && AcquiringGround()) { moveDirection = planarMoveDirection; currentState = PlayerStates.Idle; return; } if (input.Current.JumpInput) { moveDirection = collisionVector * 8; currentState = PlayerStates.Jump; return; } moveDirection -= controller.up * Gravity * 0.1f * Time.deltaTime; }
/// <summary> /// Provides raycast data based on where a SphereCast would contact the specified normal /// Raycasting downwards from a point along the controller's bottom sphere, based on the provided /// normal /// </summary> /// <param name="groundNormal">Normal of a triangle assumed to be directly below the controller</param> /// <param name="hit">Simulated SphereCast data</param> /// <returns>True if the raycast is successful</returns> private bool SimulateSphereCast(Vector3 groundNormal, out RaycastHit hit) { float groundAngle = Vector3.Angle(groundNormal, controller.up) * Mathf.Deg2Rad; Vector3 secondaryOrigin = controller.transform.position + controller.up * Tolerance; if (!Mathf.Approximately(groundAngle, 0)) { float horizontal = Mathf.Sin(groundAngle) * controller.radius; float vertical = (1.0f - Mathf.Cos(groundAngle)) * controller.radius; // Retrieve a vector pointing up the slope Vector3 r2 = Vector3.Cross(groundNormal, controller.down); Vector3 v2 = -Vector3.Cross(r2, groundNormal); secondaryOrigin += Math3d.ProjectVectorOnPlane(controller.up, v2).normalized *horizontal + controller.up * vertical; } if (Physics.Raycast(secondaryOrigin, controller.down, out hit, Mathf.Infinity, walkable, triggerInteraction)) { // Remove the tolerance from the distance travelled hit.distance -= Tolerance + TinyTolerance; return(true); } else { return(false); } }
private void HandleEdgeCollision(CollisionSphere collisionSphere, RaycastHit hit) { Vector3 towardCenter = Math3d.ProjectVectorOnPlane( playerView.Up, (playerView.Position - hit.point).normalized * settings.epsilon ); Quaternion planeAwayRotation = Quaternion.AngleAxis( settings.edgeCollisionRotateDegree, Vector3.Cross(towardCenter, playerView.Up) ); Vector3 awayCenter = planeAwayRotation * -towardCenter; Vector3 nearPoint = hit.point + towardCenter + (playerView.Up * settings.epsilon); Vector3 farPoint = hit.point + (awayCenter * settings.edgeCollisionFarPointMultiplier); RaycastHit nearHit; RaycastHit farHit; Raycast(nearPoint, playerView.Down, out nearHit); Raycast(farPoint, playerView.Down, out farHit); nearGround = new GroundHit(nearHit); farGround = new GroundHit(farHit); // If we are standing on surface that should be counted as a // wall, attempt to flush against it on the ground if (Vector3.Angle(hit.normal, playerView.Up) > collidable.StandAngle) { FlushGround(collisionSphere, hit); } // If we are standing on a ledge then face the nearest center of // the player view, which should be steep enough to be counted as // a wall. Retrieve the ground it is connected to at its base, if // there is one. if ((Vector3.Angle(nearHit.normal, playerView.Up) > collidable.StandAngle) || (nearHit.distance > settings.tolerance)) { Collidable nearCollidable = GetCollidable(nearHit); if (Vector3.Angle(nearHit.normal, playerView.Up) > nearCollidable.StandAngle) { Vector3 downslopeDirection = CollisionMath.DownslopeDirection(nearHit.normal, playerView.Down); RaycastHit stepHit; if (Raycast(nearPoint, downslopeDirection, out stepHit)) { stepGround = new GroundHit(stepHit); } } else { stepGround = new GroundHit(nearHit); } } }
void DoubleJump_EnterState() { Vector3 planarMoveDirection = Math3d.ProjectVectorOnPlane(controller.up, moveDirection); Vector3 verticalMoveDirection = moveDirection - planarMoveDirection; jumpCount = 2; moveDirection -= verticalMoveDirection; moveDirection += controller.up * CalculateJumpSpeed(JumpHeight, Gravity); }
void Float_SuperUpdate() { if (AcquiringGround()) { moveDirection = Math3d.ProjectVectorOnPlane(controller.up, moveDirection); currentState = PlayerStates.Idle; return; } }
private void DiveRoll_SuperUpdate() { if (rpgCharacterController.CanStartAction("Idle")) { currentVelocity = Math3d.ProjectVectorOnPlane(superCharacterController.up, currentVelocity); rpgCharacterController.StartAction("Idle"); return; } currentVelocity -= superCharacterController.up * (fallGravity / 2) * superCharacterController.deltaTime; }
void Fall_SuperUpdate() { if (AcquiringGround()) { moveDirection = Math3d.ProjectVectorOnPlane(controller.up, moveDirection); currentState = PlayerStates.Idle; return; } moveDirection -= controller.up * Gravity * controller.deltaTime; }
void OnTriggerStay(Collider col) { if (col.gameObject.tag == "Player" && SuperMath.Timer(lastSpawnTime, ReloadTime)) { Vector3 targetPosition = col.transform.position + Math3d.ProjectVectorOnPlane(Vector3.up, col.GetComponent <MarioMachine>().Velocity()); Instantiate(WaterBomb, targetPosition + Height * Vector3.up, Quaternion.identity); lastSpawnTime = Time.time; } }
public float GetRequiredSpeed(Vector3 point, float angle) { Vector3 direction = point - firePoint.position; float yOffset = direction.y; direction = Math3d.ProjectVectorOnPlane(Vector3.up, direction); float distance = direction.magnitude; return(ProjectileMath.CalculateLaunchSpeed(distance, yOffset, Physics.gravity.magnitude, angle * Mathf.Deg2Rad)); }
private void Fall_SuperUpdate() { if (AcquiringGround()) { currentVelocity = Math3d.ProjectVectorOnPlane(superCharacterController.up, currentVelocity); currentState = WarriorState.Idle; warriorState = WarriorState.Idle; return; } //Normal gravity. currentVelocity -= superCharacterController.up * gravity * superCharacterController.deltaTime; }
void Spawned_EnterState() { ClampToGround(); spawnTarget = iTweenPath.GetPath(PathName)[0]; Vector3 direction = Math3d.ProjectVectorOnPlane(Vector3.up, spawnTarget - transform.position).normalized; transform.rotation = Quaternion.LookRotation(direction, Vector3.up); moveDirection = direction * 4.0f; }
private void Fall_SuperUpdate() { if (AcquiringGround()) { currentVelocity = Math3d.ProjectVectorOnPlane(superCharacterController.up, currentVelocity); currentState = RPGCharacterState.Idle; rpgCharacterState = RPGCharacterState.Idle; return; } DoubleJump(); currentVelocity -= superCharacterController.up * gravity * superCharacterController.deltaTime; }
private void GrabLedge(Vector3 ledgePosition) { Vector3 ledgeDirection = Math3d.ProjectVectorOnPlane(controller.up, transform.position - ledgePosition); lookDirection = -ledgeDirection.normalized; transform.position = ledgePosition + controller.radius * ledgeDirection.normalized; transform.position += controller.down * (controller.height + controller.radius + 0.05f); moveSpeed = 0; verticalMoveSpeed = 0; }
public void MegaSpring(Vector3 direction, float velocity, float lift) { lookDirection = Math3d.ProjectVectorOnPlane(controller.up, direction.normalized); moveSpeed = velocity; verticalMoveSpeed = lift; moveDirection = Math3d.SetVectorLength(lookDirection, moveSpeed) + controller.up * verticalMoveSpeed; currentState = MarioStates.MegaSpring; return; }
void Jump_SuperUpdate() { Vector3 planarMoveDirection = Math3d.ProjectVectorOnPlane(controller.up, moveDirection); Vector3 verticalMoveDirection = moveDirection - planarMoveDirection; planarMoveDirection = Vector3.MoveTowards(planarMoveDirection, LocalMovement() * WalkSpeed, JumpAcceleration * JumpControl * controller.deltaTime); if (Vector3.Angle(verticalMoveDirection, controller.up) > 90 && AcquiringGround()) { moveDirection = planarMoveDirection; currentState = PlayerStates.Idle; return; } foreach (var c in controller.collisionData) { if (c.normal == -controller.up) { verticalMoveDirection.y = 0; break; } } if (moveDirection.y <= 0) { currentState = PlayerStates.Fall; return; } if (input.Current.JumpInput) { currentState = PlayerStates.DoubleJump; return; } collisionVector = controller.IsOnTheWall(LocalMovement()); if (collisionVector != Vector3.zero) { currentState = PlayerStates.WallSlide; return; } if (IsOnEdge()) { currentState = PlayerStates.Climb; return; } verticalMoveDirection -= controller.up * Gravity * controller.deltaTime; moveDirection = planarMoveDirection + verticalMoveDirection; }
public void SetTargetWithBothAngleAndSpeed(Vector3 point, float angle, float speed) { currentRadian = angle * Mathf.Deg2Rad; currentSpeed = speed; Vector3 direction = point - firePoint.position; float yOffset = direction.y; direction = Math3d.ProjectVectorOnPlane(Vector3.up, direction); float distance = ProjectileMath.CalculateLandDistance(firePoint.position.y, Physics.gravity.magnitude, angle, speed); projectileArc.UpdateArc(speed, distance, Physics.gravity.magnitude, currentRadian, direction, true); SetThrowPoint(direction, currentRadian * Mathf.Rad2Deg); }
public override void Update() { base.Update(); Vector3 planarMoveDirection = Math3d.ProjectVectorOnPlane(playerView.Up, stateMachine.MoveDirection); Vector3 verticalMoveDirection = stateMachine.MoveDirection - planarMoveDirection; if (Vector3.Angle(verticalMoveDirection, playerView.Up) > 90f) { if (!playerView.Animator.GetBool("IsLanding") && playerController.FallAcquiringGround()) { playerView.Animator.SetBool("IsLanding", true); } if (playerController.AcquiringGround()) { stateMachine.MoveDirection = planarMoveDirection; if (!stateMachine.Enabled || input.Mapping.Direction.Vector == Vector2.zero) { JumpHalt(); stateMachine.ChangeState(PlayerStateType.Halt); } else { stateMachine.ChangeState(PlayerStateType.Walk); } return; } } if (stateMachine.Enabled) { planarMoveDirection = Vector3.MoveTowards( planarMoveDirection, planarMoveDirection + (stateMachine.LookDirection * player.CurrentJumpSpeed * input.Mapping.Direction.Vector.magnitude), player.CurrentJumpAcceleration * playerController.DeltaTime ); planarMoveDirection = Vector3.ClampMagnitude( planarMoveDirection, player.CurrentJumpSpeedLimit ); } verticalMoveDirection -= playerView.Up * player.CurrentGravity * playerController.DeltaTime; stateMachine.MoveDirection = planarMoveDirection + verticalMoveDirection; }
private void SlopeLimit(Vector3 initialPosition) { Vector3 groundNormal = grounding.PrimaryNormal; float groundAngle = Vector3.Angle(groundNormal, playerView.Up); if (groundAngle > grounding.Collidable.SlopeLimit) { Vector3 absoluteMoveDirection = Math3d.ProjectVectorOnPlane( groundNormal, playerView.Position - initialPosition ); Vector3 downslopeDirection = CollisionMath.DownslopeDirection(groundNormal, playerView.Down); float slopeAngle = Vector3.Angle(absoluteMoveDirection, downslopeDirection); if (slopeAngle <= settings.slopeLimitUpperBoundAngle) { return; } Vector3 resolvedPosition = Math3d.ProjectPointOnLine( initialPosition, Vector3.Cross(groundNormal, playerView.Down), playerView.Position ); Vector3 direction = Math3d.ProjectVectorOnPlane( groundNormal, resolvedPosition - playerView.Position ); RaycastHit hit; if (Physics.CapsuleCast( feetSphere.Position, headSphere.Position, maxCollisionSphereRadius, direction.normalized, out hit, direction.magnitude, settings.walkableLayerMask )) { playerView.Position += downslopeDirection * hit.distance; } else { playerView.Position += direction; } } }
/// <summary> /// /// </summary> /// <returns></returns> private bool SlopeLimit() { Vector3 groundNormal = currentGround.GetNormal(); float angle = Vector3.Angle(groundNormal, up); float standAngle = GroundCollisionAttribute.DEFAULT_STAND_ANGLE; float slopeLimit = GroundCollisionAttribute.DEFAULT_SLOPE_LIMIT; if (currentGround.collisionAttribute != null) { standAngle = currentGround.collisionAttribute.StandAngle; slopeLimit = currentGround.collisionAttribute.SlopeLimit; } if (angle >= slopeLimit) { Vector3 absoluteMoveDirection = Math3d.ProjectVectorOnPlane(groundNormal, transform.position - _posBeforeCorrection); // Retrieve a vector pointing down the slope Vector3 r = Vector3.Cross(groundNormal, down); Vector3 v = Vector3.Cross(r, groundNormal); float absoluteAngle = Vector3.Angle(absoluteMoveDirection, v); if (absoluteAngle <= 90.0f) { return(false); } // Calculate where to place the controller on the slope, or at the bottom, based on the desired movement distance Vector3 resolvedPosition = Math3d.ProjectPointOnLine(_posBeforeCorrection, r, transform.position); Vector3 direction = Math3d.ProjectVectorOnPlane(groundNormal, resolvedPosition - transform.position); RaycastHit hit; // Check if our path to our resolved position is blocked by any colliders if (Physics.CapsuleCast(SpherePosition(feet), SpherePosition(head), radius, direction.normalized, out hit, direction.magnitude, Walkable, triggerInteraction)) { transform.position += v.normalized * hit.distance; } else { transform.position += direction; } return(true); } return(false); }
public void SetTargetWithAngle(Vector3 point, float angle) { currentAngle = angle; Vector3 direction = point - firePoint.position; float yOffset = -direction.y; direction = Math3d.ProjectVectorOnPlane(Vector3.up, direction); float distance = direction.magnitude; currentSpeed = ProjectileMath.LaunchSpeed(distance, yOffset, Physics.gravity.magnitude, angle * Mathf.Deg2Rad); projectileArc.UpdateArc(currentSpeed, distance, Physics.gravity.magnitude, currentAngle * Mathf.Deg2Rad, direction, true); SetTurret(direction, currentAngle); }