C++ Monster Roaming Functionality - c++

Question

I have a working monster system that follows players around by moving a certain distance towards the players 2D (X, Y) location.
However, I now want to make it so these monsters roam around at random time intervals for a short distance. Say we have a monster that can travel anywhere from 200-300 cm/sec.
I need to know how to accurately determine the monsters destination location (X, Y). Currently I simply pick a random number between 200-300 and then add those values to the monsters current X & Y value. Although doing this will sometimes exceed the desired distance traveled.
My question is, how can I pick a location on an X, Y grid that is a certain distance away from our current location.
This is the moving code I have right now...
// Determines if position is changed via addition or subtraction.
const int positive_or_negative = RandomValueInRange_New(0, 1);
// Determines how much to move in each direction
const int x = RandomValueInRange(200, 300);
const int y = RandomValueInRange(200, 300);
if (positive_or_negative == 1)
{
location.Move(x, y);
}
else
{
location.Move(-x, -y);
}

Answer 1

This sounds like a job for polar co-ordinates. You want to pick a random point on a circle of a given (random, within a range) radius, then add that point to your monster's current location:
// pick a random angle, in radians, between 0 and 2*pi
const double angle = ((double) RandomValueInRange(0, 628318)) / 100000.0;
// pick a random distance between min and max distance
const double radius = RandomValueInRange(200, 300);
// Convert polar co-ordinates to rectilinear co-ordinate deltas
const double dX = cos(angle)*radius;
const double dY = sin(angle)*radius;
// Add the rectilinear co-ordinates to your monster's position
location.Move(dX, dY);

Answer 2

There are at least two approaches you can use. The approach you use will affect the distribution of destination coordinates.
The first, as stated by Jeremy, is the use polar coordinates. r = random(200, 300); ang = random(0, 360). This with result in a higher density of coordinates at r=200 than at r=300 due to the fact that a “ring” at the largest radius will have 50% more area than the ring at the smallest radius, due to its larger circumstance.
A second approach would be to generate two random values x = random(-300, 300); y = random(-300, 300) repeatedly until a random pair passes the constraint of a distance between 200 & 300.
int dX, dY, d2;
do {
dX = RandomValueInRange(-300, 300);
dY = RandomValueInRange(-300, 300);
d2 = dX*dX + dY*dY;
} while ( d2 < 200*200 || d2 > 300*300);
location.Move(dX, dY);
This produces an even distribution in space, but at the cost of repeated random number generation. Only 43.6% of random pairs will fall in the desired area, so the loop will typically execute 2 to 3 times before generating an acceptable pair.
While this distribution is even in x-y space, it is not even in terms of distance. A monster will on average move more than 250cm, since there is more area in the ring between 250cm to 300cm than in the ring from 200cm to 250cm.
A more realistic move distribution would bias the next move based on the previous move. For instance, doing an about-face is probably a low probability event. Unless the monster was actively guarding a given location, in which case it might be the highest likelihood action!
Without more detail on exactly how the monster should behave, and if you aren’t overly concerned with the distribution, the simplest generation is going to be the polar coordinate route, which gives a legal position from exactly 2 random number generations and no looping.