Still confused on the difference between complex and euclid.Vector2
[ doc:
http://www.partiallydisassembled.net/euclid/vector-classes.html ]
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):
I'll try it out.
@emile: ( continued from above ), I'm trying to understand how/why
complex
numbers are used.
Here is my Vector2 equivalent to your code.
It looks like you treat complex same way I treat euclid.Vector2 ?
Am I
missing something?
from euclid import Vector2
class Spaceship():
def __init__(self, pos=Vector2(0,0), max_accel=100):
self.pos = pos
self.vel = Vector2(0, 0) # or'speed'. changed named to not be
confused as Scalar
self.accel = Vector2(0, 1.) # or 'direction'
self.boosters_on = False
self.max_accel = max_accel
def update(self, dt):
if self.boosters_on:
self.vel += self.accel * self.max_accel * dt
self.pos += self.vel * dt
--
Jake