Rope or rope like objects can be found in many places in game. Cable lines between poles, vines hanging from trees or spiders swinging by web othey all have similar kind of behavior. We are going to create that and see how it can be used in game.

The rope we are going to create will two components. Vertices and line. We will call them `Node` and `Stick`. A `Stick` will have two `Nodes` connected to it making link between them. `Node` will be responsible for simulating movements, maintaining structure of rope and handling physics. There will also be fixed nodes that will not move and will act as attached point for rope. `Stick` will act as constraints between two nodes keeping them within certain distance.

### Creating a Node

As `Node` is responsible for movement, let's first create a method to move it. In our `Node` class define move function that will move it.

``````    void Move(Vector3 moveVector) {
//get movement vector and translate it with that vector
transform.Translate(moveVector);
}``````

Movement of vertices will be done from `FixedUpdate`. We will be calculating it's velocity using position in previous frame and add gravity to it. It will make our node react to gravity making it fall freely.

``````    public bool isFixed; //if true this point will not be affected by gravity or stick constraint and act as connected point for rope
public static float gravity = -9.8 f; //value of gravity to calculate the rate at which object falls
public Vector2 previousPosition; //position of vertices in previous update. It will be used to calculate velocity in next frame

//We are not directly using FixedUpdate here because order of updating is importaint.
//So just create a method for now which will be updated from other place
public void UpdateNode() {
if (isFixed) return; //dont move if fixed point

Vector2 velocity = (Vector2) transform.position - previousPosition;
calculate velocity to preserve momentum
previousPosition = transform.position; //save current position to be used in next update

velocity += Vector2.up * gravity * Time.fixedDeltaTime * Time.fixedDeltaTime;

//move object
Move(velocity);
}``````

### Creating a Stick

We will be using `LineRenderer` to make a stick. It will have two nodes that will be connected and a `length` parameter that will define constraints for the distance between two nodes.

First, let's create a method to make a line between two nodes

``````    private LineRenderer lineRenderer;

private void UpdateLineRenderer() {
lineRenderer.SetPositions(new [] {
node1.transform.position,
node2.transform.position
});
}``````

Now, we need to create a `UpdateStick` method for handling constraints between nodes. This will just move nodes towards each other if their distance is larger than `length`

``````    public float length;

Vector2 center = (node1.transform.position + node2.transform.position) / 2; //calculate midpoint betwen node

if (!node1.isFixed) {
Vector2 node1DirTowardCenter = ((Vector2) node1.transform.position - center).normalized; //calculate direction towards center point
node1.transform.position = node1DirTowardCenter * length / 2 + center; //move point at the right distance i.e half the length from center

}

if (!node2.isFixed) {
//do same for another node
Vector2 node2DirTowardCenter = ((Vector2) node2.transform.position - center).normalized;
node2.transform.position = node2DirTowardCenter * length / 2 + center;
}

//make a line between two node after updating node position is completed
UpdateLineRenderer();
}``````

Now we need to initialize `lineRenderer` and calculate position at `Awake`

``````    private void Awake() {
lineRenderer = GetComponent < LineRenderer > ();
lineRenderer.useWorldSpace = true;
length = Vector2.Distance(node1.transform.position, node2.transform.position); //calculate distance between nodes at begining. we will be using it to maintain distance throughout simulation

UpdateLineRenderer(); //update line renderer to connect two points
}``````

### Creating a Rope

Finally, we will create a `Rope` class that will update each vertice and stick. Updates will happen in `FixedUpdate` method as it will give a consistent result.

``````public class Rope: MonoBehaviour {
public Node[] nodes; //collection for nodes in scene

public Stick[] sticks; //collection for sticks in scene

private void Awake() {
//find all nodes and sticks in scene
nodes = FindObjectsOfType < Node > ();
sticks = FindObjectsOfType < Stick > ();
}

void FixedUpdate() {
//update nodes at first
foreach(Node node in nodes) {
node.UpdateNode();
}

for (int i = 0; i < 3; i++) {
//we may want to update sticks multiple times because one node will be updated by multipe sticks.
//doing multiple iteration will give precise result but single iteration is enough for simpler games

//update sticks to maintain distance between nodes
foreach(Stick stick in sticks) {
//update only if gameobject is active
if (stick.gameObject.activeSelf)
}
}
}
}``````

### Setting up in Unity editor

Create a `GameObject` for `Node` and `Stick` in the scene and add respective scripts to it.`Stick` should have `LineRenderer` attached to it. Connect the  required `Nodes` in `node1` and `node2` of stick. Finally, add `Rope` script in scene and we are good to go.

Also, we can enable or disable `Stick` object to get cutting and joining effect of rope.

## Further improvements and customization

This is a really basic and simple system to make rope-like objects. Using only this will not be enough for a good game. So, what else to add to it? Well, there are many. You can add wind effect along with gravity in node. Or add collider in vertices so that it will interact with other physical objects. Also, another interesting thing to do is make a playable character that can grab/release a `Node` and swing like a monkey swinging from rope to rope. Basic cloth simulation can also be done by arranging `Node` in the grid and connecting four nodes around it with `Stick`. There are just so many possibilities.

Thank you for reading. If you have any question or suggestion please comment below.