x determines the range, y is the starting point of the range and it’s actually a part of it from what I understand.

So it makes sense, because “including” 3 (the starting point), the other numbers (4,5,6,7) make 5.

I always just used the “random actuator” or the “random” python module with the: “ran = random.randint(3,7)”, but now that I think of it, I find the “getRandomFloat()” method to be much cleaner (don’t have to import anything).

Not only that, but using getRandomFloat() produces a better random number. Using the random actuator gives the same results every time unless the seed is changed.

Here is a little track to script that I pieced together from a bunch of sources and from reading about rotation matrices. I can’t claim any of it as mine as all this is pretty well already been done before. But it worked for me. Of course it might not work either and if anyone cares to make it better…well go ahead.

# vector functions needed
#
# displacement of vectors
#
def vsub(end, begin):
return [(end[0]-begin[0]), (end[1]-begin[1]), (end[2]-begin[2])]
#
# magnitude of the vector
#
def vmag(vec):
return math.sqrt(math.pow(vec[0],2)+math.pow(vec[1],2)+math.pow(vec[2],2))
#
# normalize a vector by dividing by vmag
#
def vnorm(vec):
mag = vmag(vec)
return [(vec[0]/mag), (vec[1]/mag), (vec[2]/mag)]
#
# cross product is perpindicular to input vectors
# don't mix these up or normals could point wrong direction
#
def vcross(vec1, vec2):
cross = [(vec1[1]*vec2[2] - vec1[2]*vec2[1]), \
(vec1[2]*vec2[0] - vec1[0]*vec2[2]), \
(vec1[0]*vec2[1] - vec1[1]*vec2[0])]
# print "cross:", cross
return cross
#
# Calculate Out vector
#
def vout(end, begin):
out = vsub(end, begin)
out = vnorm(out)
return out
#
# Calculate Up vector
#
def vrt(vec):
upw = [0.0, 0.0, 0.1]
up = vcross(vec, upw)
return vnorm(up)
#
# calculate right
#
import math
import GameLogic as gl
scene = gl.getCurrentScene()
cont = gl.getCurrentController()
own = cont.getOwner()
pointer = scene.getObjectList()["OBPointer"]
target = scene.getObjectList()["OBYTarget"]
tpos = target.getPosition()
ppos = pointer.getPosition()
out = vout(tpos, ppos)
right = vrt(out)
up = vcross(right, out)
#set Orientation with proper values
pointer.setOrientation([\
[right[0], out[0], up[0]], \
[right[1], out[1], up[1]], \
[right[2], out[2], up[2]]\
])

oh, nuts to that! orientation matrices are evil (my trig teacher sucked…)!! i’m still not understanding how the random number code provided doesn’t include the number 8 in the system. I’m reading it as random number from (0.0 to 1.0) * 5, which as intergers would be {0,1,2,3,4,5}, and then increment all of them by 3, which gives {3,4,5,6,7,8}. Why is this wrong? is there something i’m not getting? oh, and God, why would you want to change an object’s name in the middle of a game, anyway? even if it were possible, it’s just too messy, unless if you don’t mean the object itself, but more like a character name, which can be done by simply modifying a property (call it “name”).

duh! i know that!! jeeze, all you people think i’m stupid or something… i meant the random floating point number generator. does that go from 0.0 to 1.0, including both numbers? because, according to my logic, if you multiply the possible result by 5, you should receive one of 6 different numbers, when truncated that is. i listed the possible outcomes in my previous post, so just work off that.

I had sort of an idea that if a “track to” script was to complicated, I would just use logic bricks and have the object always track to and object called TRACK or something, and change the name of any object I wanted it to track to. Of course, now that I think back on it, it seems kind of stupid, because I could just have the object track to an empty and just change the position of the empty… anyways, thanks for the advice.

ok, took me a while to get around to doing this, but i finally tested the getRandomFloat() thing.

list = [0,0,0,0,0,0]
pos = 0
attempts = 0
print list
while pos < len(list) and attempts < 100:
num = int(GameLogic.getRandomFloat() * 5) + 3
count = 0
isIn = 0
while count < len(list) and isIn != 1:
if num == list[count]:
isIn = 1
count += 1
if isIn == 0:
list[pos] = num
pos += 1
attempts += 1
print list

Probably could have done this more efficiently, but this is, like, 5 min of work, without really caring. I anticipated the possibility that the random number generator doesn’t hit 0.0 or 1.0, and added a variable to limit the amount of loops. Apparently, as the test shows, it doesn’t hit those numbers. I probably could have saved myself, and everyone else, the annoyance of this post if i had just read the GameLogic.pdf file that i downloaded, but this was much more fun.