93 lines
3.2 KiB
C#
93 lines
3.2 KiB
C#
using UnityEngine;
|
|
|
|
/// <summary>
|
|
/// Adds a wobble (rocking and vertical movement) effect to the object, based on speed and time.
|
|
/// </summary>
|
|
public class WobbleBehavior : MonoBehaviour
|
|
{
|
|
[Header("Wobble Settings")]
|
|
public float wobbleFrequency = 1.5f;
|
|
/// <summary>
|
|
/// Max degrees from horizontal.
|
|
/// </summary>
|
|
public float baseWobbleAmplitude = 8f;
|
|
/// <summary>
|
|
/// How much speed affects amplitude.
|
|
/// </summary>
|
|
public float speedToAmplitude = 2f;
|
|
/// <summary>
|
|
/// Maximum allowed rotation in degrees.
|
|
/// </summary>
|
|
public float maxRotationLimit = 45f;
|
|
|
|
[Header("Vertical Movement Settings")]
|
|
public float verticalFrequency = 0.5f;
|
|
/// <summary>
|
|
/// How far the object moves up/down.
|
|
/// </summary>
|
|
public float verticalAmplitude = 0.5f;
|
|
|
|
[Header("Smoothing Settings")]
|
|
public float velocitySmoothing = 10f;
|
|
/// <summary>
|
|
/// How quickly rotation is smoothed.
|
|
/// </summary>
|
|
public float rotationSmoothing = 10f;
|
|
|
|
private Vector3 lastPosition;
|
|
private float wobbleTime;
|
|
private float velocity;
|
|
private Vector3 basePosition;
|
|
private float verticalOffset;
|
|
private float smoothedVelocity;
|
|
private float smoothedAngle;
|
|
|
|
/// <summary>
|
|
/// The current velocity of the object (horizontal only).
|
|
/// </summary>
|
|
public float Velocity => velocity;
|
|
/// <summary>
|
|
/// The current vertical offset due to wobble.
|
|
/// </summary>
|
|
public float VerticalOffset => verticalOffset;
|
|
|
|
void Start()
|
|
{
|
|
lastPosition = transform.position;
|
|
smoothedVelocity = 0f;
|
|
smoothedAngle = 0f;
|
|
}
|
|
|
|
void Update()
|
|
{
|
|
// Calculate movement speed (exclude vertical wobble from velocity calculation)
|
|
Vector3 horizontalPosition = transform.position;
|
|
horizontalPosition.y = 0f; // Ignore Y for velocity if only horizontal movement matters
|
|
Vector3 horizontalLastPosition = lastPosition;
|
|
horizontalLastPosition.y = 0f;
|
|
velocity = (horizontalPosition - horizontalLastPosition).magnitude / Time.deltaTime;
|
|
lastPosition = transform.position;
|
|
|
|
// Smooth velocity to prevent jitter
|
|
smoothedVelocity = Mathf.Lerp(smoothedVelocity, velocity, velocitySmoothing * Time.deltaTime);
|
|
|
|
// Wobble amplitude scales with smoothed speed, but always has a base value
|
|
float amplitude = baseWobbleAmplitude + smoothedVelocity * speedToAmplitude;
|
|
amplitude = Mathf.Min(amplitude, maxRotationLimit); // Prevent amplitude from exceeding limit
|
|
|
|
// Oscillate around horizontal (0 degrees)
|
|
wobbleTime += Time.deltaTime * wobbleFrequency;
|
|
float targetAngle = Mathf.Sin(wobbleTime) * amplitude;
|
|
targetAngle = Mathf.Clamp(targetAngle, -maxRotationLimit, maxRotationLimit);
|
|
|
|
// Smooth the rotation angle
|
|
smoothedAngle = Mathf.Lerp(smoothedAngle, targetAngle, rotationSmoothing * Time.deltaTime);
|
|
|
|
// Apply rotation (Z axis for 2D)
|
|
transform.localRotation = Quaternion.Euler(0f, 0f, smoothedAngle);
|
|
|
|
// Calculate vertical up/down movement (wave riding) only once
|
|
verticalOffset = Mathf.Sin(wobbleTime * verticalFrequency) * verticalAmplitude;
|
|
}
|
|
}
|