Sort and delegate working together

Unity Engine
1

Hi all,

Currently I am studying a video tutorial I found on Youtube and it has been a little difficult because I am not a programmer

Basically, I am having some issues trying to understand “delegate” and “sort” working together. This is the code

targets.Sort(delegate(Transform t1, Transform t2)
	{
	return Vector3.Distance(myTransform.position,t1.transform.position)
				.CompareTo(
				Vector3.Distance(myTransform.position,t2.transform.position));
	});

What I cannot get is this part of the code: (Transform t1, Transform t2)

My questions are, variables t1 and t2 are used to retrieve values from the list “targets”? How “Sort” knows what values t1 and t2 should take?

Thanks in advance for your answer

2

Ah… This is a nested function inside a Class It is not defined like that in Javascript though, looks more like C#

Also, the CompareTo is not a defined function of Vector3.

This is more how it would be defined in Javascript:

class targetClass{
	var myTransform : Transform;
	
	function Sort(t1:Transform, t2:Transform){
		return Vector3.Distance(myTransform.position,t1.transform.position)
				>(Vector3.Distance(myTransform.position,t2.transform.position));
	}
};

var targets : targetClass;

function Start(){
if(targets.myTransform==null)return;
print(targets.Sort(Vector3(0,0,0),Vector3(0,1,0)));
}
3

Hi BigMisterB ,

Sorry, I forgot to mention it is C#. The code is working but I wanted to understand the magic behind the lines.

Regards

4

Sort uses a built-in sorting method (uses the QuickSort algorithm) where given the list of items to sort, it uses the method you pass to it to determine which item goes first.

So for example, say I had a list of integers that I needed to sort, it might be as simple as:

private bool IntCompare(int value1, int value2)
{
	if (value1 < value2)
	{
		return -1;
	}
	else if (value1 == value2)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

int[] list = new int[]{1,9,3,5,2,6};
list.Sort(IntCompare);

In this case, Unity automatically performs the sorting, but does so according to the rules you setup in “IntCompare”. (return -1 means “value1” comes before “value2”, 0 means they’re equal, 1 means “value1” comes after “value2”)

In C#, referencing methods like that is done using “delgates”. The code you posted is just a short-hand way of creating delegates. In my first example, I declared a full class member for the sorting. But it could just as easily be rewritten using an anonymous method (a method that doesn’t strictly belong to a class):

int[] list = new int[]{1,9,3,5,2,6};
list.Sort(delegate(int value1, int value2)
	{
		if (value1 < value2)
		{
			return -1;
		}
		else if (value1 == value2)
		{
			return 0;
		}
		else
		{
			return 1;
		}
	}
);

So these are useful when you want to apply special sorting rules for special objects (sort your transforms in order to say, an arbitrary central point. Sort them by their magnitude. Or whatever)

It’s late, so hopefully I didn’t put much misinformation/mistakes in that. Hopefully that’ll help you out.

5

Hi FizixMan,

Thanks for taking time to answer. I think, I understand the concept. In this case, the anonymous method is pointing CompareTo, right? That is why when I try this (Transform t1, Transform t2, Transform t3), the code does not work.

Also, I found another way to write the same code using lamdda expression.

targets.Sort((t1, t2) => 
			Vector3.Distance(myTransform.position,t1.transform.position)
			.CompareTo
			(Vector3.Distance(myTransform.position,t2.transform.position))
			);
	}

Thanks again

6

Sort is “type-safe.” That means it is locked to comparing two entries. This is because the sort method is designed to sort the array by comparing only two items at once (the quicksort algorithm). Trying to give it 3 entries should result in a compile error 'cause the sort method doesn’t know what to do with it. As you picked up on though, it’s very easy to introduce more variables into your sorting method. Especially with your discovery of lambdas (which are awesome by the way)

Also, you don’t need to use the “CompareTo” in there, that’s just an easier way of using a default comparison of floats (from low-to-high). You could have written the method as:

targets.Sort( (t1, t2) =>
{
	float t1Distance = Vector3.Distance(myTransform.position, t1.transform.position);
	float t2Distance = Vector3.Distance(myTransform.position, t2.transform.position);
	
	if (t1Distance < t2Distance)
	{
		return -1;
	}

	if (t1Distance > t2Distance)
	{
		return 1;
	}

	return 0;
});

If you wanted to sort all even numbers before odd numbers, you wouldn’t use CompareTo, but instead you would use something like “number % 2 == 0”.

7

Thanks FizixMan. Now I have a better understanding of delegate and Sort function.

Regards from Costa Rica