Move around scripts to cleanup the Minigame structure

Assets/Scripts/Minigames/DivingForPictures/Player/RopeBreaker.cs

@@ -0,0 +1,331 @@
+using UnityEngine;
+using System.Collections;
+using GogoGaga.OptimizedRopesAndCables;
+
+/// <summary>
+/// Component that allows breaking a rope in half.
+/// Attach this to the same GameObject that has a Rope and LineRenderer component.
+/// </summary>
+public class RopeBreaker : MonoBehaviour
+{
+    [Header("Break Settings")]
+    [Tooltip("Position along rope where break occurs (0-1)")]
+    [Range(0f, 1f)]
+    [SerializeField] private float breakPosition = 0.5f;
+
+    [Tooltip("Effect to spawn at break point (optional)")]
+    [SerializeField] private GameObject breakEffect;
+
+    [Tooltip("Sound to play when rope breaks (optional)")]
+    [SerializeField] private AudioClip breakSound;
+
+    [Header("Physics Settings")]
+    [Tooltip("Follow speed for the rope physics simulation")]
+    [SerializeField] private float ropeFollowSpeed = 5f;
+    
+    [Tooltip("Trailing amount for the rope physics simulation")]
+    [SerializeField] private float ropeTrailing = 0.2f;
+
+    [Tooltip("Gravity strength applied to hanging rope end")]
+    [SerializeField] private float ropeGravityStrength = 9.8f;
+    
+    [Tooltip("How strongly the rope tries to hang vertically")]
+    [SerializeField] private float ropeVerticalHangStrength = 2f;
+    
+    [Tooltip("Damping for physics movement (higher = less bouncy)")]
+    [SerializeField] private float ropeDamping = 0.3f;
+    
+    [Tooltip("Initial separation distance between rope ends when broken")]
+    [SerializeField] private float initialSeparationDistance = 0.1f;
+    
+    [Tooltip("Initial downward impulse for falling rope end")]
+    [SerializeField] private float initialFallImpulse = 2.0f;
+
+    // Private references
+    private Rope originalRope;
+    private LineRenderer originalLineRenderer;
+    private GameObject firstHalfRope;
+    private GameObject secondHalfRope;
+    private Rope firstHalfRopeComponent;
+    private Rope secondHalfRopeComponent;
+    private Transform breakPointTransform;
+    private Transform secondBreakTransform;
+
+    private void Awake()
+    {
+        // Get references to the required components
+        originalRope = GetComponent<Rope>();
+        originalLineRenderer = GetComponent<LineRenderer>();
+
+        if (originalRope == null || originalLineRenderer == null)
+        {
+            Debug.LogError("RopeBreaker requires both Rope and LineRenderer components on the same GameObject");
+            enabled = false;
+        }
+    }
+
+    /// <summary>
+    /// Breaks the rope at the specified position.
+    /// </summary>
+    /// <param name="breakPositionOverride">Optional override for break position (0-1)</param>
+    /// <returns>True if rope was broken successfully, false otherwise</returns>
+    public bool BreakRope(float? breakPositionOverride = null)
+    {
+        if (originalRope == null || !originalRope.StartPoint || !originalRope.EndPoint)
+        {
+            Debug.LogError("Cannot break rope: Missing rope component or endpoints");
+            return false;
+        }
+
+        // Use override position if provided
+        float breakPos = breakPositionOverride ?? breakPosition;
+        breakPos = Mathf.Clamp01(breakPos);
+
+        // Get the world position at the break point
+        Vector3 breakPointPosition = originalRope.GetPointAt(breakPos);
+
+        // Create a transform at the break point to use as an anchor
+        CreateBreakPointTransform(breakPointPosition);
+
+        // Create two new rope GameObjects
+        CreateRopeSegments(breakPointPosition);
+        
+        // Hide the original rope
+        originalLineRenderer.enabled = false;
+        
+        // Play effects
+        PlayBreakEffects(breakPointPosition);
+
+        return true;
+    }
+
+    /// <summary>
+    /// Creates a transform at the break point to use as an anchor
+    /// </summary>
+    private void CreateBreakPointTransform(Vector3 breakPointPosition)
+    {
+        // Store references to the original rope endpoints
+        Transform originalStartPoint = originalRope.StartPoint;
+        Transform originalEndPoint = originalRope.EndPoint;
+        
+        // Create a new GameObject for the break point (attached to Player)
+        GameObject breakPointObj = new GameObject("RopeBreakPoint");
+        breakPointTransform = breakPointObj.transform;
+        breakPointTransform.position = breakPointPosition;
+        breakPointTransform.SetParent(transform.parent); // Parent to the same parent as the rope
+        
+        // Add the physics follower component to the break point
+        RopeEndPhysicsFollower follower = breakPointObj.AddComponent<RopeEndPhysicsFollower>();
+        
+        // Set specific transform to follow instead of using tag
+        follower.SetTargetTransform(originalStartPoint);
+        follower.canFall = false; // Player rope end doesn't fall
+        follower.followSpeed = ropeFollowSpeed;
+        follower.trailing = ropeTrailing;
+        
+        // Create second break point (for the rock-attached end)
+        GameObject secondBreakObj = new GameObject("RopeBreakPoint_Second");
+        secondBreakTransform = secondBreakObj.transform;
+        secondBreakTransform.position = breakPointPosition;
+        secondBreakTransform.SetParent(transform.parent);
+        
+        // Add physics behavior to second break point
+        RopeEndPhysicsFollower secondFollower = secondBreakObj.AddComponent<RopeEndPhysicsFollower>();
+        
+        // Set specific transform to follow instead of using tag
+        secondFollower.SetTargetTransform(originalEndPoint);
+        secondFollower.canFall = true; // Rock end can fall
+        secondFollower.followSpeed = ropeFollowSpeed;
+        secondFollower.trailing = ropeTrailing;
+        secondFollower.gravityStrength = ropeGravityStrength;
+        secondFollower.verticalHangStrength = ropeVerticalHangStrength;
+        secondFollower.damping = ropeDamping;
+        secondFollower.initialFallImpulse = initialFallImpulse;
+        
+        // Create initial separation
+        Vector3 direction = (originalEndPoint.position - breakPointPosition).normalized;
+        if (direction.magnitude < 0.01f) direction = Vector3.down;
+        
+        breakPointTransform.position -= direction * initialSeparationDistance * 0.5f;
+        secondBreakTransform.position += direction * initialSeparationDistance * 0.5f;
+    }
+
+    /// <summary>
+    /// Creates two new rope GameObjects for the broken segments
+    /// </summary>
+    private void CreateRopeSegments(Vector3 breakPointPosition)
+    {
+        // Create the first half rope (from start to break point)
+        firstHalfRope = new GameObject("Rope_FirstHalf");
+        firstHalfRope.transform.position = transform.position;
+        firstHalfRope.transform.rotation = transform.rotation;
+        firstHalfRope.transform.SetParent(transform.parent);
+        
+        // Add Rope component which automatically adds LineRenderer due to RequireComponent
+        firstHalfRopeComponent = firstHalfRope.AddComponent<Rope>();
+        
+        // Get the LineRenderer that was automatically added
+        LineRenderer firstLineRenderer = firstHalfRope.GetComponent<LineRenderer>();
+        if (firstLineRenderer == null)
+        {
+            // Only add if somehow not created (shouldn't happen, but safety check)
+            firstLineRenderer = firstHalfRope.AddComponent<LineRenderer>();
+        }
+        CopyLineRendererProperties(originalLineRenderer, firstLineRenderer);
+
+        // Create the second half rope (from break point to end)
+        secondHalfRope = new GameObject("Rope_SecondHalf");
+        secondHalfRope.transform.position = transform.position;
+        secondHalfRope.transform.rotation = transform.rotation;
+        secondHalfRope.transform.SetParent(transform.parent);
+        
+        // Add Rope component which automatically adds LineRenderer due to RequireComponent
+        secondHalfRopeComponent = secondHalfRope.AddComponent<Rope>();
+        
+        // Get the LineRenderer that was automatically added
+        LineRenderer secondLineRenderer = secondHalfRope.GetComponent<LineRenderer>();
+        if (secondLineRenderer == null)
+        {
+            // Only add if somehow not created (shouldn't happen, but safety check)
+            secondLineRenderer = secondHalfRope.AddComponent<LineRenderer>();
+        }
+        CopyLineRendererProperties(originalLineRenderer, secondLineRenderer);
+
+        // Configure the first half rope
+        firstHalfRopeComponent.SetStartPoint(originalRope.StartPoint);
+        firstHalfRopeComponent.SetEndPoint(breakPointTransform, false); // Don't recalculate yet
+        
+        // Copy properties from original rope
+        CopyRopeProperties(originalRope, firstHalfRopeComponent);
+        
+        // Explicitly initialize the rope
+        firstHalfRopeComponent.Initialize();
+        
+        // Now force recalculation after initialization
+        firstHalfRopeComponent.RecalculateRope();
+        
+        // Configure the second half rope - REVERSED: Rock (End) is now Start, Break point is now End
+        secondHalfRopeComponent.SetStartPoint(originalRope.EndPoint);
+        secondHalfRopeComponent.SetEndPoint(secondBreakTransform, false); // Don't recalculate yet
+        
+        // Copy properties from original rope
+        CopyRopeProperties(originalRope, secondHalfRopeComponent);
+        
+        // Explicitly initialize the rope
+        secondHalfRopeComponent.Initialize();
+        
+        // Now force recalculation after initialization
+        secondHalfRopeComponent.RecalculateRope();
+        
+        // Set explicit rope length constraints on the physics followers
+        // This needs to be done after the rope segments are created so we have the correct rope lengths
+        RopeEndPhysicsFollower playerFollower = breakPointTransform.GetComponent<RopeEndPhysicsFollower>();
+        if (playerFollower != null)
+        {
+            playerFollower.SetMaxDistance(firstHalfRopeComponent.ropeLength);
+        }
+        
+        RopeEndPhysicsFollower rockFollower = secondBreakTransform.GetComponent<RopeEndPhysicsFollower>();
+        if (rockFollower != null)
+        {
+            rockFollower.SetMaxDistance(secondHalfRopeComponent.ropeLength);
+        }
+    }
+
+    /// <summary>
+    /// Copies properties from one LineRenderer to another
+    /// </summary>
+    private void CopyLineRendererProperties(LineRenderer source, LineRenderer destination)
+    {
+        // Copy material
+        destination.material = source.material;
+        
+        // Copy colors
+        destination.startColor = source.startColor;
+        destination.endColor = source.endColor;
+        
+        // Copy width
+        destination.startWidth = source.startWidth;
+        destination.endWidth = source.endWidth;
+        
+        // Copy other properties
+        destination.numCornerVertices = source.numCornerVertices;
+        destination.numCapVertices = source.numCapVertices;
+        destination.alignment = source.alignment;
+        destination.textureMode = source.textureMode;
+        destination.generateLightingData = source.generateLightingData;
+        destination.useWorldSpace = source.useWorldSpace;
+        destination.loop = source.loop;
+        destination.sortingLayerID = source.sortingLayerID;
+        destination.sortingOrder = source.sortingOrder;
+    }
+
+    /// <summary>
+    /// Copies properties from one Rope to another
+    /// </summary>
+    private void CopyRopeProperties(Rope source, Rope destination)
+    {
+        destination.linePoints = source.linePoints;
+        destination.stiffness = source.stiffness;
+        destination.damping = source.damping;
+        destination.ropeLength = source.ropeLength / 2f; // Halve the rope length for each segment
+        destination.ropeWidth = source.ropeWidth;
+        destination.midPointWeight = source.midPointWeight;
+        destination.midPointPosition = source.midPointPosition;
+        
+        // Recalculate the rope to update its appearance
+        destination.RecalculateRope();
+    }
+
+    /// <summary>
+    /// Plays visual and audio effects at the break point
+    /// </summary>
+    private void PlayBreakEffects(Vector3 breakPointPosition)
+    {
+        // Spawn break effect if assigned
+        if (breakEffect != null)
+        {
+            Instantiate(breakEffect, breakPointPosition, Quaternion.identity);
+        }
+        
+        // Play break sound if assigned
+        if (breakSound != null)
+        {
+            AudioSource.PlayClipAtPoint(breakSound, breakPointPosition);
+        }
+    }
+
+    /// <summary>
+    /// Restores the original rope and cleans up the broken pieces
+    /// </summary>
+    public void RestoreRope()
+    {
+        // Re-enable the original rope
+        if (originalLineRenderer != null)
+        {
+            originalLineRenderer.enabled = true;
+        }
+        
+        // Clean up the broken rope pieces
+        if (firstHalfRope != null)
+        {
+            Destroy(firstHalfRope);
+        }
+        
+        if (secondHalfRope != null)
+        {
+            Destroy(secondHalfRope);
+        }
+        
+        // Clean up both break points
+        if (breakPointTransform != null)
+        {
+            Destroy(breakPointTransform.gameObject);
+        }
+        
+        if (secondBreakTransform != null)
+        {
+            Destroy(secondBreakTransform.gameObject);
+        }
+    }
+}