Help Rope extension, vibration and collision

Code:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using Obi;

using System;



public class RopeCreate : MonoBehaviour

{

  



    [Header("Obi")]

    [SerializeField] Transform ropeEnd;

    public ObiSolver solver;

    public ObiCollider2D character;

    public float hookExtendRetractSpeed = 2;

    public Material material;

    public ObiRopeSection section;



    private ObiRope rope;

    private ObiRopeBlueprint blueprint;

    private ObiRopeExtrudedRenderer ropeRenderer;



    private ObiRopeCursor cursor;



    private RaycastHit hookAttachment;



    public Rigidbody2D characterRb;

    void Awake()

    {



        // Create both the rope and the solver:    

        rope = gameObject.AddComponent<ObiRope>();

        ropeRenderer = gameObject.AddComponent<ObiRopeExtrudedRenderer>();

        ropeRenderer.section = section;

        ropeRenderer.uvScale = new Vector2(1, 5);

        ropeRenderer.normalizeV = false;

        ropeRenderer.uvAnchor = 1;

        rope.GetComponent<MeshRenderer>().material = material;



        // Setup a blueprint for the rope:

        blueprint = ScriptableObject.CreateInstance<ObiRopeBlueprint>();

        blueprint.resolution = 0.5f;



        // Tweak rope parameters:

        rope.maxBending = 0.02f;



        // Add a cursor to be able to change rope length:

        cursor = rope.gameObject.AddComponent<ObiRopeCursor>();

        cursor.cursorMu = 0;

        cursor.direction = true;

    }



    private void Start()

    {

       



        if (!rope.isLoaded)

            LaunchHook();



        Debug.Log(GetRopeLength());

    }



    private void OnDestroy()

    {

        DestroyImmediate(blueprint);

    }



    /**

     * Raycast against the scene to see if we can attach the hook to something.

     */

    private void LaunchHook()

    {





        StartCoroutine(AttachHook());





    }



    private IEnumerator AttachHook()

    {



        yield return null;



        Vector3 startLocal = transform.position;

        Vector3 endLocal = ropeEnd.position;

        Vector3 direction = (endLocal - startLocal).normalized;



       

        blueprint.path.Clear();

        blueprint.path.AddControlPoint(startLocal, -direction, direction, Vector3.up, 0.1f, 0.1f, 1, 1, Color.white, "Hook start");

        blueprint.path.AddControlPoint(endLocal, -direction, direction, Vector3.up, 0.1f, 0.1f, 1, 1, Color.white, "Hook end");

        blueprint.path.FlushEvents();



       

        yield return blueprint.Generate();



        rope.ropeBlueprint = blueprint;

        rope.GetComponent<MeshRenderer>().enabled = true;



       

        var pinConstraints = rope.GetConstraintsByType(Oni.ConstraintType.Pin) as ObiConstraints<ObiPinConstraintsBatch>;

        pinConstraints.Clear();

        var batch = new ObiPinConstraintsBatch();



       

        batch.AddConstraint(rope.solverIndices[0], character, transform.localPosition, Quaternion.identity, 0, 0, float.PositiveInfinity);



       

        batch.AddConstraint(rope.solverIndices[blueprint.activeParticleCount - 1],

                            ropeEnd.GetComponent<ObiColliderBase>(),

                            //ropeEnd.position,

                            //ropeEnd.InverseTransformPoint(ropeStart.position),

                            Vector3.zero,

                            Quaternion.identity, 0, 0, float.PositiveInfinity);



        batch.activeConstraintCount = 2;

        pinConstraints.AddBatch(batch);



        rope.SetConstraintsDirty(Oni.ConstraintType.Pin);

    } 



   

    public void RopeIncrease()

    {

        cursor.ChangeLength(rope.restLength + hookExtendRetractSpeed * Time.deltaTime);

    }

    public void RopeDecrease()

    {

        cursor.ChangeLength(rope.restLength - hookExtendRetractSpeed * Time.deltaTime );



    }



    public float GetStrain()

    {

        float strain = rope.restLength / rope.CalculateLength();

        return strain;

    }



    public float GetRopeLength()

    {

        return rope.CalculateLength();

    }

}

Code:

public class CapsuleMove : MonoBehaviour

{

    [SerializeField]RopeCreate ropeCreate;

    [Header("Move")]

    const float speed = 500f;

    

    private Vector3 mOffset;

    private float mZCoord;

    private bool active;

    private Rigidbody2D rb;

    float startRotation;



    [SerializeField] public bool isRopeLengthMax = false;



    public Vector2 startPos;



    private Vector2 previousPosition;

    private void Start()

    {

        rb = GetComponent<Rigidbody2D>();



       

    }



    private void OnMouseDown()

    {

        



        mZCoord = Camera.main.WorldToScreenPoint(transform.position).z;

        mOffset = transform.position - GetMouseAsWorldPoint();

        active = true;

        rb.velocity = Vector2.zero;

        rb.gravityScale = 0f;

        

        rb.constraints &= ~RigidbodyConstraints2D.FreezePositionX;

        rb.constraints &= ~RigidbodyConstraints2D.FreezePositionY;



    }



    private void OnMouseUp()

    {

        MouseDownEnded();

    }

    private void MouseDownEnded()

    {

        active = false;

        rb.gravityScale = 1f;

        rb.velocity = Vector2.zero;

        // rb.freezeRotation = true;

        rb.constraints = RigidbodyConstraints2D.FreezePositionX | RigidbodyConstraints2D.FreezePositionY | RigidbodyConstraints2D.FreezeRotation;        

    }



    private Vector3 GetMouseAsWorldPoint()

    {

        Vector3 mousePoint = Input.mousePosition;

        mousePoint.z = mZCoord;

        return Camera.main.ScreenToWorldPoint(mousePoint);

    }



    private void FixedUpdate()

    {

       

        if (isRopeLengthMax)

        {

            MouseDownEnded();



            return;

        }

        if (active)

        {



            Vector2 desiredPosition = (Vector2)(GetMouseAsWorldPoint() + mOffset);

            Vector2 direction = desiredPosition - rb.position;

            rb.velocity = direction.magnitude > 0.1f ? direction * Time.fixedDeltaTime * speed : Vector2.zero;



           



            float distanceMoved = Vector2.Distance(rb.position, previousPosition);

            if (distanceMoved < 0.05f)

            {

                return;

            }



            if (ropeCreate.GetStrain() > .9)

            {

                ropeCreate.RopeDecrease();

            }

            else

            {

                ropeCreate.RopeIncrease();

               // Debug.Log("Lenght" + ropeCreate.GetRopeLength());

            }



            previousPosition = rb.position;



        }

    }

}

Code:

var smoother = GetComponent<ObiPathSmoother>();

var position = smoother.GetSectionAt(normalizedCoord).position;

Code:

public void OnRopeContactEnter(ObiSolver solver, Oni.Contact contact)

 {

     var world = ObiColliderWorld.GetInstance();

     var col = world.colliderHandles[contact.bodyB].owner;



     if (col != null && col.GetComponent<Item>() != null && !col.GetComponent<Item>().ColliderTriggerControl())

     {

         if (!GameManager.instance.usedItems.Contains(col.GetComponent<Item>()))

         {

             GameManager.instance.UsedItemsAdd(col.GetComponent<Item>());

            

             Debug.Log("Contact: " + col.name);



             

             int particleIndex = contact.bodyA;

             Vector2 contactPoint = solver.positions[particleIndex] + contact.normal * contact.distance;





         }

     }

 }