# Random Position between ranges

Does anyone have a good algorithm for generating a random y position for spawning a block, which takes into account a minimum and maximum height, allowing player to to jump on the block.

Blocks will continually be spawned, so the player must always be able to jump onto the next block, bearing in mind the minimum position which would be the ground, and the maximum which would the players jump height bearing in mind the ceiling

• Blakey87 is obviously beginning game development, if you are going to cast a vote to close, write a comment as to why, don't just vote to close because it is easy. Jun 23, 2011 at 23:13
• @AttackingHobo you are 100% correct and thanks, I come from a web based background (PHP), and this is my first time at trying to create a game, never used objective C before so everything is new to me, I dont normally ask for help but I thought why not Jun 24, 2011 at 7:56
• @AttackingHobo I voted to close because the question basically asks for a way to get a random value between a given min and max, which is really trivial, as long as you figure out how to get a random value on your system (which is not the question). I think beginners questions are ok, but there's got to be a threshold. Also all the answers given don't provide a solution in plain Objective-C, so no real help there (assuming the OP is really totally new to Objective-C) Jun 24, 2011 at 10:33
• @bummzack: Generating a good random value between two numbers is actually something I see people do wrong very often; usually their results are either biased, or unnecessarily slow.
– user744
Jun 24, 2011 at 18:12
• @bummzack: There are two problems and you're conflating them - first, generating good random numbers. That's really hard. Second, generating good random numbers between two given values. That's not really hard, but people still screw it up a lot. (Duck's answer is biased, CaseyB's answer confuses noise and randomness, MrXee's answer is unbiased but unnecessarily slow.)
– user744
Jun 25, 2011 at 12:26

You just have to generate some boundaries for the blocks you are going to make, maybe due to the last block or other limitations in your game; for example, if your game has some level of ground, no block should start below ground level. Having those parameters set, it's really easy to create a random number which has all the features you required.

In your game example: imagine a block starting at NewStartPositionY and ending at NewEndPositionY. We know GroundLevel is the ground height (you consider it as zero) and CeilingLevel is the ceiling height. A character might jump at most MaxJump units. Some other parameters might be PlayerHeight, which is the height of the character, and LastStartPositionY and LastEndPositionY which define the last block, and let's take MinimumBlockSize as the minimum size of platform. Knowing all these values you can set your boundaries :

// to initialize boundaries
NewStartPositionY = GroundLevel;
NewEndPositionT = min (LastEndPositionY + MaxJump,  CeilingLevel - PlayerHeight)
// to set actual random value
NewStartPositionY = random (NewEndPositionY - NewStartPositionY - MinimumBlockSize)
NewEndPositionY = random (NewEndPositionY - NewStartPositionY - MinimumBlockSize) + NewStartPositionY + MinimumBlockSize;


Edit:

Here is what the above code actually does; I just expanded it since it seems to cause many a headache! (It just needs more variables and does more operations but the result is the same.)

// -- first we define what are the boundaries of generated blocks
// it's obvious that no block can be under the ground level
MinimumBoundaryY = GroundLevel;
// we need to make sure player can jump over the new level
// and at the same time we have to make sure player can go over it
// and not hit the ceiling so we choose the minimum value from them both
MaximumBoundaryY = min(lastEndPositionY + maxJump, CeilingLevel - PlayerHeight)
// --now initialize startPosition of the Block
// we want the block to at least have MinimumBlockSize height
// so the start position should be somewhere between minimumBoundaryY
// and MaximumBoundaryY - MinimumBlockSize
StartYRange = MaximumBoundaryY - MinimumBoundaryY - minimumBlockSize;
// and now we a random value we assign the actual value of new StartPosition
newStartPositionY = random() % StartYRange + MinimumBlockSize;
// --now as the last part we have to calculate endPosition of the new block
// again we first calculate the range for endPosition value.
// note that end position should always be somewhere between
// beginPositionY + MinimumBlockHeight and maximumBlockHeight so the range well be
EndYRange = MaximumBoundaryY - newStartPositionY - MinimumBlockHeight;
// in the end just set the EndPosition of the Block, we now it's variation range
// and we know it's the minimum valid value is beginPositionY + MinimumBlockheight
NewEndPositionY = random() % EndYRange + newStartPositionY + MinimumBlockHeight;


Hope this second piece of code helps you all understand what my code does! (and change your downvotes to upvotes :D).

• I don't understand why this was chosen as the accepted answer. Why do you generate two random values? Also your ys1 (which is the start position of the new block) can become bigger or smaller than ye1 (it can even end up with the same size). Your example does something... but it doesn't position a block randomly, so that it's reachable by the player. Jun 24, 2011 at 14:53
• @Gajet this seems incredibly complicated for what is a very simple idea..and your use of variable names is very confusing. I don't understand it. Jun 24, 2011 at 16:50
• Use variables that are descriptive, not cryptic. Jun 24, 2011 at 17:03
• "Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live." — Martin Golding Jun 24, 2011 at 17:11
• @Gajet, please check the revision history. It seems there was an edit collision and you might want to roll back the text, at least, to my version. Jun 27, 2011 at 21:22

@Gajet's answer is impossible to follow (so I'm not even convinced it will work), and what I think @The Communist Duck meant his solution to be...

block_y = ground_y + random() % (previousBlock_y + playerJumpHeight)


...will be heavily biased towards creating blocks with y-values centered around ground_y + playerJumpHeight.

The easiest way to produce more satisfying results would be, rather than generate a height between ground_y and previousBlock_y + playerJumpHeight, generate a random value between previousBlock_y - playerJumpHeight and previousBlock_y + playerJumpHeight.

Of course, since we want to take ground_y and maxBlockHeight into consideration also, we really want to find a random value between max(ground_y, previousBlock_y - playerJumpHeight) and min(maxBlockHeight, previousBlock_y + playerJumpHeight). This will skew our distribution a bit (biased towards the center of the screen), but not enough to be noticeable.

The simplest way to do this would be

//delta_y is a random number between -/+ playerJumpHeight
min_y = max(ground_y, previousBlock_y - playerJumpHeight)
max_y = min(maxBlockHeight, previousBlock_y + playerJumpHeight)
range_y = max_y - min_y
block_y = random() % range_y + min_y


If you then want the block to have a random height as well, just generate a random number between ground_y and block_y to be the height.

 There is a way to have a probability of jumping down by any amount, while still giving the player equal probability of being anywhere on the screen at any given point.

Thanks to Didier Piau on the math forums for figuring this out. The full explanation is complex, so I'll leave it out; the curious can visit that page, from which I generalized this algorithm. The algorithm itself is actually pretty simple, though.

int getNextBlockHeight()
{
int playingFieldHeight = screen_y - ground_y;
int canonicalBlockMaxHeight = playingFieldHeight - playerHeight;
int nextBlockMaxHeight = min(currentBlockHeight + playerJumpHeight, canonicalBlockMaxHeight);

//Let's divide the screen vertically into chunks of size playerJumpHeight.
//This code makes it so that each chunk is approximately twice as likely as being chosen
//as the previous chunk
float canonicalHeightRatio = (float)canonicalBlockMaxHeight / playerJumpHeight;
float nextHeightRatio = (float)nextBlockMaxHeight / playerJumpHeight;

//The following looks complicated, but really it just ensures that the minimum is 0, the maximum is
//nextBlockMaxHeight, and everything in between is mapped logarithmically
float randomMin = pow(2, -canonicalHeightRatio);
float randomMax = pow(2, nextHeightRatio-canonicalHeightRatio);
float randomVal = randFloat(randomMin, randomMax);
float randomHeightRatio = log2(randVal)+canonicalHeightRatio;
return (int)(randomHeightRatio*playerJumpHeight) + ground_y;
}

//Return the log-base-2 of a number
const float log_of_2 = log(2);
float log2(float value)
{
return log(value) / log_of_2;
}

//Generates a random floating-point number between min and max
float randFloat(float min, float max)
{
float randomNormalized = (float)rand()/RAND_MAX; //Between 0.0 and 1.0
return randomNormalized*(max-min) + min;
}

• hope you understand what my answer were (and why it was accepted) now. Jun 26, 2011 at 20:54

Generate a random y value between a ground y value g and a max height m. m is simply g+character jump height.

I don't know how Obj-C's random works, but usually you'll want something like:

block_y = (random() % m) + g;

• random() % m produces non-uniform results. For a game it probably doesn't matter too much; on the other hand for a game the system rand()/random() functions may not be acceptable, and as long as you're going to deal with that you might as well do this part right too.
– user744
Jun 24, 2011 at 18:30
• Since the OP is asking for Objective-C I'd suggest arc4random as the random function. Jun 24, 2011 at 21:35
• -1 I think OP wanted both a random height off the ground AND a random block-height. Even if he didn't, this will not work - it will always produce a value between g and 2*g + jumpHeight. And even if you fixed it to be say what I assume you meant (m = previousBlockHeight + jumpHeight), it would still produce unsatisfying results - it would be heavily biased towards generating blocks near the ground, meaning the character would rarely be near the top of the screen. Jun 24, 2011 at 22:35

If you're using it, you can generate numbers between two values using the following messages on the Random class:

/* Inclusive low to exclusive high. */
- (int32_t)uniformIntFrom:(int32_t)low to:(int32_t)high;
- (uint32_t)uniformUnsignedFrom:(uint32_t)low to:(uint32_t)high;

/* Inclusive low to inclusive high. */
- (float)uniformFloatFrom:(float)low to:(float)high;
- (double)uniformDoubleFrom:(double)low to:(double)high;

/* Inclusive 0 to exclusive 1. */
- (float)uniformFloat;
- (double)uniformDouble;


If you are curious about how to generate a good random number between two values, this is the main portion of the source code for it:

uint32_t range = high - low;
uint32_t reject;
uint32_t n;

if (range < 2)
return low;

/* Trick borrowed from OpenBSD's arc4random_uniform. Figure out
* the size of the bias given the requested range, and throw away
* numbers within the biased range.
*/

if (range > 0x80000000)
reject = 1 + ~range;
else
reject = ((max - (range * 2)) + 1) % range;

do {
n = [engine next];
} while (n < reject);
return low + (n % range);


Where [engine next] gives me a number between 0 and max (which is usually UINT_MAX, i.e. 232-1).

Not sure how this translates in Obj-C but here's my version for C++. You want to normalize your random value before turning it into a specific range so the rand() stays uniform.

float randomHeight( float heightMin, float heightMax )
{
float normRand = rand() / (float) RAND_MAX;
float range = normRand * (heightMax - heightMin);
return range + heightMin;
}


Note that rand() returns values from 0 to RAND_MAX so if you can find the equivalent in Obj-C, you can just replace these values with yours.

• Same problem as @Communist Duck's answer, will generate blocks that are heavily biased towards the bottom of the screen - being near the top of the screen would be rare, especially if playerJumpHeight is small. Jun 24, 2011 at 23:09
• @BlueRaja-DannyPtflughoeft: he has some value for his height min value. it makes his answer diffrent from the one CommunistDuck gave and more similar to mine. just by changeing heightMin in each cycle he will get out of hook. Jun 26, 2011 at 20:28

It sounds like what you want is just a 1D string of Perlin Noise. This is a very well documented problem and there are several examples available on the internet.

• I don't think it is. It doesn't account for jumping accessibility at all. Jun 23, 2011 at 21:12
• It gives you a value from 0.0 - 1.0 that varies in a nice distribution. All you need to do is map that so that 0.0 is 0.0 and 1.0 is your max height! Jun 23, 2011 at 21:48
• so does random(), but this person is obviously confused about how to do it. Jun 23, 2011 at 23:09
• Perlin noise is a continuous, and thereby very non-random, distribution. All we need here is a random number between two values.
– user744
Jun 24, 2011 at 18:31