Speeding up Random position of objects on a grid - procedural-generation

Question

Currently I doing the following and I am certain it is a slow way of doing it. Basically I run through a grid and determine if a) a star is present and b) what type is there if one is. What I think I should be doing is using my known value (eg current_star_density * 0.25) and using that to plot a series of points. I guess the part I am uncertain of is how I then prevent duplication when I plot that quantity.
Any help would be gratefully received. This is the relevant part of the code.
for (var z = 0; z < gridZ; z++)
{
for (var x= 0; x < gridX; x++)
{
star_chance = Random.value * 1000; // * 1000
if (star_chance <= current_star_density)
{
star_class = Random.value * 100;
if (star_class <=1) // add in the other star types etc
{
new_star = Instantiate(prefab_o, Vector3(x * 10 + transform.position.x - 500, 0, z * 10 + transform.position.z - 500), Quaternion.identity);
new_star.transform.parent = this.transform;
new_star.name = String.Format("O:{0}.{1}:{2}.{3}",galaxy_X,x,galaxy_Y,z);
}
else if (star_class <=2)
{
new_star = Instantiate(prefab_b, Vector3(x * 10 + transform.position.x - 500, 0, z * 10 + transform.position.z - 500), Quaternion.identity);
new_star.transform.parent = this.transform;
new_star.name = String.Format("B:{0}.{1}:{2}.{3}",galaxy_X,x,galaxy_Y,z);
}
else if (star_class <=5)
{
new_star = Instantiate(prefab_a, Vector3(x * 10 + transform.position.x - 500, 0, z * 10 + transform.position.z - 500), Quaternion.identity);
new_star.transform.parent = this.transform;
new_star.name = String.Format("A:{0}.{1}:{2}.{3}",galaxy_X,x,galaxy_Y,z);
}
else if (star_class <=10)
{
new_star = Instantiate(prefab_f, Vector3(x * 10 + transform.position.x - 500, 0, z * 10 + transform.position.z - 500), Quaternion.identity);
new_star.transform.parent = this.transform;
new_star.name = String.Format("F:{0}.{1}:{2}.{3}",galaxy_X,x,galaxy_Y,z);
}
else if (star_class <=20)
{
new_star = Instantiate(prefab_g, Vector3(x * 10 + transform.position.x - 500, 0, z * 10 + transform.position.z - 500), Quaternion.identity);
new_star.transform.parent = this.transform;
new_star.name = String.Format("G:{0}.{1}:{2}.{3}",galaxy_X,x,galaxy_Y,z);
}
else if (star_class <=40)
{
new_star = Instantiate(prefab_k, Vector3(x * 10 + transform.position.x - 500, 0, z * 10 + transform.position.z - 500), Quaternion.identity);
new_star.transform.parent = this.transform;
new_star.name = String.Format("K:{0}.{1}:{2}.{3}",galaxy_X,x,galaxy_Y,z);
}
else if (star_class <=80)
{
new_star = Instantiate(prefab_m, Vector3(x * 10 + transform.position.x - 500, 0, z * 10 + transform.position.z - 500), Quaternion.identity);
new_star.transform.parent = this.transform;
new_star.name = String.Format("M:{0}.{1}:{2}.{3}",galaxy_X,x,galaxy_Y,z);
}
}
}
}

Answer 1

I'm not really sure what kind of end result you are trying to achieve, but do you perhaps mean something like this (pseudocode)?
star_density is a number between 0 and 1 here, one meaning full density and 0 nothing.
// We have a fixed amount of stars based on the grid size and density
// You could add a small random multiplier if you wish
for (var i = 0; i < gridX * gridZ * star_density; ++i) {
// Pick a random position until we find an empty one
do {
var x = floor(Random.value * gridX);
var z = floor(Random.value * gridY);
} while (grid[z][x].containsStar());
var new_star = /* Do all the star initialization stuff and randomization */
grid[z][x] = new_star;
}
This assumes you can use a grid to perform a look up of star existence. I didn't see where you store the stars, but even if you don't have an actual grid there currently, you could use a temporary array for the placement algorithm.
This should be more efficient with low star densities (say, below 30% - totally made up number that would need some experimentation) when collisions are unlikely, but at some point if will run worse than your current one, due to low probability of finding a free slot and using two random values instead of one in yours. Another drawback is that if the RNG is crappy, this may theoretically enter an infinite loop with big grid and very high density. You could counter the worst case performances with simply picking between which algorithm to use based on the density.