When pathfinding I use one cost array as well as an integer array holding the index locations of pawns, so I Get from two different arrays each step of the search. I also Get from a vector array when placing the instanced meshes displaying which tiles can be moved to.
So I just did some testing. I first made two forloops. One where I added the index of the forloop to six different float arrays and one where I added the index to six different floats in a struct array. Adding to the struct array took approximately half the time of adding to the six float arrays. I then ran a foreachloop on the struct array where I printed the values of all the floats in each struct and another loop where I printed the floats from all the six separate arrays. The time this took was identical in both scenarios.
From this, it seems to me that getting from multiple arrays when doing pathfinding does not matter, and is just as quick as getting from a single struct array. Adding to a struct array is quicker than adding to a number of arrays equalling the number of variables in your struct. However, setting a single variable is quicker with simple arrays than with struct arrays, as you have to get and reset all the variables in each struct each time you want to change a single one. I rarely add many variables to different arrays at the same time, while I often set a single item in an array, which means that keeping multiple arrays still seems like the superior solution in my case. So to reiterate your example of three gets from 3 80K arrays should be just as quick as getting all the three variables from a 80K struct array if my results are correct.
Using actors, this is different, since you can change a single variable without resetting all the others. This might be the best of both worlds performance wise, but that presupposes that casting to and getting actors in the game world is very quick and efficient. Ian Shaddens pathfinding seems to indicate that this is the case, but I’m unsure what solution would be quickest in a direct comparison.
That you got little performance drop from spawning so many invisible actors is promising. However, I will only go that route if there are significant performance gains in using them. I guess to me placing thousands of actors feels a bit inelegant when you could instead have it stored in arrays, though such matters of taste should probably be left out of this. That performance drops with very high numbers also shows that the invisible actors do have an impact, even if it is small, and even though it takes a lot of actors to get there I’m assuming you’re using a pretty beefy computer.
I am perhaps a bit biased in this since I’ve been using arrays and would have to do some major changes if invisible actors turned out to be superior. I’m trying to keep an open mind here, though, and will test things out and let the results speak for themselves.