On Wed, Jan 21, 2009 at 9:24 PM, Casey Duncan
<casey@xxxxxxxxxxx> wrote:
Here's some example code with some commonly used functions. Addition and subtraction are built into the complex type and work as expected (I use the real part
So far, this looks like euclid.Vector2. Are you doing the same thing, only using 'real as the x component, and 'imag' as y? ( Meaning you are using complex instead of tuple, equivalent to using vector2 instead of tuple ? )
Or, I think i'm missing something. What is the advantage to to use this over euclid.Vector2? [ more below ]
for x and the imaginary part for y). complex multiply can be used to rotate vectors:
Does complex multiply behind the scenes do something like this?
def rad2v(rad,mag=1.): # convert radians to vector with magnitude
return mag*Vector2(cos(rad), sin(rad))
def v2rad(v): return atan2(v.y, v.x) # convert vector to radians
def mod_angle(v,rad): # add radians to vector's orientation
r = v2rad(v)
r+=rad
return rad2v( r, v.magnitude() )
>>> v = rad2v( radians(142.8),2.5)
# now equals: deg=142.8, mag=2.5, v=Vector2(-1.99, 1.51)
>>> v = mod_angle( v, radians(3.))
# now equals: deg=145.8, mag=2.5, v=Vector2(-2.07, 1.41)
# 2D vectors using python complex numbers
def radians(vector):
return atan2(vector.imag, vector.real)
def unit(radians):
return cmath.exp(radians * 1j)
def normal(vector):
L = length(vector)
if L == 0:
return vector2()
else:
return vector / L
def clamp(vector, max_length):
L = length(vector)
if L > max_length:
return vector * (max_length / L)
else:
return vector
At first, this code looks the same, except there are new functions: .radians(v) and unit(r). Radians looks like a 'convert vector to euler radians angle'.
But whatis .unit()? I'm guessing it's to create a new unit vector in the angle of 'radians.' But calling it with a few values, I'm not getting what I was expecting.
Is it the equivalent of rad2v(r) for Vector2, but unit(r) does the same for complex numbers?
def distance(vector1, vector2):
return length(vector1 - vector2)This is good if the list may change during iteration. If you do this repeatedly in a given frame, it might be better to create a custom class (perhaps subclass set) that contains a stable set of the actors. When you add or remove, these are stored in ancillary sets rather than changing the stable set immediately. An update method called at the beginning of each frame adds and removes the items from the ancillary sets to update the stable set. These ancillary sets are then cleared. This mean less memory allocation/cleanup and work copying the lists
class StableSet(set):