Optimizing the movement of many gameobjects

So I'm making a game where the enemies are composed of several individual parts (ie: blocks). Each of these blocks can (and often do) have movement outside of the movement of the enemy. This movement is currently being executed in each block's FixedUpdate(). After looking at the profiler (post optimizing dynamic batching, implementing object pooling, and reducing the vertices count in my objects) I've determined that the main draw on my CPU is the massive number of calls to the enemy blocks' FixedUpdates.

Specifically, the lines that are causing the most CPU usage (~26%) are these:

Code (CSharp):

1. if(moving)
2.         {
3.             if (reverse)
4.             {
5.                 transform.localPosition = Vector3.MoveTowards(transform.localPosition, start, speed * Time.deltaTime);
6.                 if (transform.localPosition == start)
7.                 {
8.                     reverse = !reverse;
9.                 }
10.             }
11.             else
12.             {
13.                 transform.localPosition = Vector3.MoveTowards(transform.localPosition, location, speed * Time.deltaTime);
14.                 if (transform.localPosition == location)
15.                 {
16.                     reverse = !reverse;
17.                 }
18.             }
19.         }

What would be the best way to optimize this code for it to be run by over 1000 objects?

 

A couple of things:

- Don't put a script on each thing. Instead, have one script that moves all of them. That'll save you some overhead when you're moving this many things.
- Move all of those objects to the top of the hierarchy. Moving things that have parents are slightly more expensive.
- Reduce the number of if-statements:
- Instead of the moving-bool, have things that are not moving in their own list, which you don't do anything with.
- Instead of having a reverse bool, change the value of your destination when you get to the current destination.

All of these are absurd micro-optimizations that are only applicable to instances of moving thousands of things. Don't take this as general advice.

If that's not enough to get acceptable performance, look into replacing the objects with instancing. That's harder code to write, but it's a system designed for exactly this scenario.

 

Thanks! I'll go test those optimizations out to see if they make any drastic improvements. I did somewhat simplify the issue, thus some optimizations such as removing their parents or implementing instancing wouldn't work for my particular use case.

I'm also looking into seeing if not moving them when they're outside the camera view will help as well, but I need to make sure the check is worth the payoff in terms of performance.

 

You already got a great answer, just 1 more thing.

I'm not sure exactly how your game works, but you could also try to have some blocks getting refreshed less often than FixedUpdate. You can look into this thread for using coroutines efficiently. If you've got a thousand objects, my guess is that not all of them are visible to the player, and/or they are far enough away for the player not to notice that they're moving more jaggedly. But the main offender I see in your code is the "reverse" bool.

 

Can confirm that after implementing a bunch of these changes (and some others) that my performance did increase significantly :]

@DroidifyDevs, I considered both disabling movement past a distance or making it happen every other fixed update (or on a coroutine) but decided against it since occasionally my camera does zoom out and I didn't want everything to look low quality when that happens if it doesn't have to.

 

Hi.

It's been a long time since this question was asked and answered. But anyway I will give the state pattern as a suggestion to optimize code.

This links give an idea. Usually they have interesting ways of avoiding ifs
http://www.habrador.com/tutorials/programming-patterns/6-state-pattern/
https://denisrizov.com/2016/03/13/state-pattern/