def test_if_vector(self):
v = eu.Vector2(0.0, 0.0)
if v:
eval_true = True
else:
eval_true = False
self.assertFalse(eval_true)
v = eu.Vector2(1.0, 0.0)
if v:
eval_true = True
else:
eval_true = False
self.assertTrue(eval_true)
v = eu.Vector2(0.0, 1.0)
if v:
eval_true = True
else:
eval_true = False
self.assertTrue(eval_true)
v = eu.Vector2(1.0, 1.0)
if v:
eval_true = True
else:
eval_true = False
self.assertTrue(eval_true)
def test_dot(self):
a = (3.0, 7.0)
b = (1.0, 2.0)
va = eu.Vector2(*a)
vb = eu.Vector2(*b)
d = va.dot(vb)
self.assertTrue(abs(d - (3.0 + 14.0)) < fe)
def bounds(self):
# Horizontal bounds
if self.position.x > self.pong.screen_width + self.size or self.position.x + self.size < 0:
if self.position.x > self.pong.screen_width:
self.pong.opponent.score += 1
self.pong.opponent.set_emotion(
score_need=self.pong.opponent.score_need + 5)
self.pong.agent.set_emotion(
score_need=self.pong.agent.score_need - 3)
self.pong.agent.set_emotion()
elif self.position.x < 0:
self.pong.agent.score += 1
self.pong.agent.set_emotion(
score_need=self.pong.agent.score_need + 5)
self.pong.opponent.set_emotion(
score_need=self.pong.opponent.score_need - 3)
self.position.x = self.pong.screen_width / 2
self.position.y = self.pong.screen_height / 2
if random.randint(0, 1) == 0:
self.velocity = -(self.position - self.pong.agent.position
).normalize() * self.speed
else:
self.velocity = -(self.position - self.pong.opponent.position
).normalize() * self.speed
if self.paddle_collision(self.pong.empathizer):
self.position.x = self.position.x + self.pong.empathizer.max_length + self.size / 2
self.position.y = self.position.y + self.pong.empathizer.max_length + self.size / 2
return
# Vertical bounds
if self.position.y <= self.size:
self.position.y = 2 * self.size - self.position.y
self.velocity = self.velocity.reflect(euclid.Vector2(0, 1))
elif self.position.y >= self.pong.screen_height - self.size:
self.position.y = 2 * (self.pong.screen_height -
self.size) - self.position.y
self.velocity = self.velocity.reflect(euclid.Vector2(0, 1))
position_previous = self.position
def unfreeze(pos):
# Frozen ball
if pos == position_previous:
self.velocity = self.get_random_velocity(0, 2 * math.pi)
# Paddle collisions
if self.paddle_collision(self.pong.agent):
self.pong.agent.set_emotion(
return_need=self.pong.agent.return_need + 2)
unfreeze(self.position)
if self.paddle_collision(self.pong.opponent):
self.pong.opponent.set_emotion(
return_need=self.pong.opponent.return_need + 2)
unfreeze(self.position)
if self.paddle_collision(self.pong.empathizer):
unfreeze(self.position)
def test_reflect(self):
a = (1.0, 1.0)
v = eu.Vector2(*a)
normal = eu.Vector2(*(1.0, 0.0))
w = v.reflect(normal)
self.assertFalse(w is v)
self.assertTrue(abs(w - eu.Vector2(*(-1.0, 1.0))) < fe)
self.assertTrue(abs(w.reflect(normal) - v) < fe)
def test_angle_oriented(self):
aa = 25
v = eu.Vector2(3.0 * cos(radians(aa)), 3.0 * sin(radians(aa)))
bb = 35
w = eu.Vector2(5.0 * cos(radians(bb)), 5.0 * sin(radians(bb)))
self.assertTrue(abs(degrees(v.angle_oriented(w)) - 10.0) < fe)
# orientation matters
self.assertEqual(v.angle_oriented(w), -w.angle_oriented(v))
def set_steering_angle(self, theta):
rot_matrix = euclid.Matrix3.new_rotate(
theta) # radians counter-clockwise
forward_axis = euclid.Vector2(0.0, 1.0)
right_axis = euclid.Vector2(1.0, 0.0)
self.forward_axis = rot_matrix * forward_axis
self.right_axis = rot_matrix * right_axis
def test_normalize(self):
a = (3.0, 0.0)
v = eu.Vector2(*a)
v.normalize()
self.assertTrue(abs(v - eu.Vector2(*(1.0, 0.0))) < fe)
a = (0.0, 3.0)
v = eu.Vector2(*a)
v.normalize()
self.assertTrue(abs(v - eu.Vector2(*(0.0, 1.0))) < fe)
def test_inplace_add(self):
a = (3.0, 7.0)
b = (1.0, 2.0)
va = eu.Vector2(*a)
vb = eu.Vector2(*b)
va += vb
self.assertEqual((va.x, va.y), (4.0, 9.0))
va = eu.Vector2(*a)
va += b
self.assertEqual((va.x, va.y), (4.0, 9.0))
def can_put(self, x1, y1, x2, y2):
#check put
v = euclid.Vector2(x1, y1) - euclid.Vector2(x2, y2)
if v.magnitude() == 0:
return False
y = max(y1, y2)
#print 'aca:',self.vectorReqEnergy(v), self.energy()
testenergy = (self.vectorReqEnergy(v) < self.energy())
#print y, self.ceilings
return ((self.ceilings is None) or
(y < self.ceilings)) and (testenergy)
def collide(self):
if (int(self.position.x) == (r_paddle_x - self.size[0])):
if (self.position.y +
self.size[1]) > r_paddle_y and self.position.y < (
r_paddle_y + paddle_size[1]):
self.velocity = self.velocity.reflect(euclid.Vector2(1, 0))
if (int(self.position.x) == (l_paddle_x + paddle_size[0])):
if (self.position.y +
self.size[1]) > l_paddle_y and self.position.y < (
l_paddle_y + paddle_size[1]):
self.velocity = self.velocity.reflect(euclid.Vector2(1, 0))
def test_eq_tuple(self):
a = (1.0, 2.0)
self.assertEqual(eu.Vector2(*a), a)
other = (1.0, 2.0, 3.0)
self.assertRaises(AssertionError, lambda r, s: r == s, eu.Vector2(*a),
other)
other = 1.0
self.assertRaises(AssertionError, lambda r, s: r == s, eu.Vector2(*a),
other)
def paddle_collision(self, other):
if self.ball_in_paddle_range(other):
other.update_geometry()
paddle_coords = other.geometry.exterior.coords
self.update_geometry()
# If corner
for i in range(4):
if self.geometry.contains(Point(paddle_coords[i])):
self.position -= self.velocity * self.pong.dtime
self.velocity.x = self.position.x - paddle_coords[0][0]
self.velocity.y = self.position.y - paddle_coords[0][1]
self.velocity = self.velocity.normalize() * self.speed
return True
# If side
if LineString([paddle_coords[0],
paddle_coords[1]]).intersects(self.geometry):
normal_vector = euclid.Vector2(
-paddle_coords[1][1] + paddle_coords[0][1],
paddle_coords[1][0] - paddle_coords[0][0]).normalize()
self.position -= self.velocity * self.pong.dtime
self.velocity = self.velocity.reflect(normal_vector)
return True
elif LineString([paddle_coords[1],
paddle_coords[2]]).intersects(self.geometry):
normal_vector = euclid.Vector2(
-paddle_coords[2][1] + paddle_coords[1][1],
paddle_coords[2][0] - paddle_coords[1][0]).normalize()
self.position -= self.velocity * self.pong.dtime
self.velocity = self.velocity.reflect(normal_vector)
return True
elif LineString([paddle_coords[2],
paddle_coords[3]]).intersects(self.geometry):
normal_vector = euclid.Vector2(
-paddle_coords[3][1] + paddle_coords[2][1],
paddle_coords[3][0] - paddle_coords[2][0]).normalize()
self.position -= self.velocity * self.pong.dtime
self.velocity = self.velocity.reflect(normal_vector)
return True
elif LineString([paddle_coords[3],
paddle_coords[0]]).intersects(self.geometry):
normal_vector = euclid.Vector2(
-paddle_coords[0][1] + paddle_coords[3][1],
paddle_coords[0][0] - paddle_coords[3][0]).normalize()
self.position -= self.velocity * self.pong.dtime
self.velocity = self.velocity.reflect(normal_vector)
return True
# No collision
return False
def test_normalized(self):
a = (3.0, 0.0)
v = eu.Vector2(*a)
w = v.normalized()
self.assertFalse(w is v)
self.assertTrue(abs(w - eu.Vector2(*(1.0, 0.0))) < fe)
a = (0.0, 1.0)
v = eu.Vector2(*a)
w = v.normalized()
self.assertFalse(w is v)
self.assertTrue(abs(w - eu.Vector2(*(0.0, 1.0))) < fe)
def reset(self):
self.ball.position.x = self.screen_width / 2
self.ball.position.y = self.screen_height / 2
self.ball.velocity = self.ball.get_random_velocity(0, math.pi * 2)
if self.ball.paddle_collision(self.empathizer):
self.ball.position.x = self.ball.position.x + self.empathizer.max_length + self.ball.size / 2
self.ball.position.y = self.ball.position.y + self.empathizer.max_length + self.ball.size / 2
self.empathizer.position = euclid.Vector2(self.screen_width / 2,
self.screen_width / 80)
self.agent = euclid.Vector2(
self.screen_width - self.screen_height / 10,
self.screen_height / 2)
self.opponent = euclid.Vector2(self.screen_height / 10,
self.screen_height / 2)
def __init__(self,
position,
size,
color=(255, 255, 255),
velocity=euclid.Vector2(0, 0),
accel=euclid.Vector2(0, 0),
width=1):
# use a position vector instead of x and y coordinates
self.position = position
self.size = size
self.color = color
self.width = width
self.velocity = velocity
self.accel = accel
class Puff(Blood):
pink = (250, 200, 200)
red = (255, 250, 200)
lightred = (240, 255, 255)
colors = [pink, red, lightred]
lifetimeRange = (1, 2)
left = euclid.Vector2(-2, 0)
def On_ExplosionSpecial(self, pos):
#print 'splode'
pos = toScreenPos(pos)
for drop in range(0, randint(2, 4)):
vector = euclid.Vector2(randint(-2, 3), randint(-2, 3))
fb = Fireball(pos, vector)
self.sprites.append(fb)
def On_WhiffSpecial(self, pos):
#print 'whiff'
pos = toScreenPos(pos)
for drop in range(0, randint(5, 8)):
vector = euclid.Vector2(randint(-2, 3), randint(-2, 3))
puff = Puff(pos, vector)
self.sprites.append(puff)
def bounce(self):
if self.position.x <= self.size:
self.position.x = 2 * self.size - self.position.x
self.velocity = self.velocity.reflect(euclid.Vector2(1, 0))
elif self.position.x >= screen_width - self.size:
self.position.x = 2 * (screen_width - self.size) - self.position.x
self.velocity = self.velocity.reflect(euclid.Vector2(1, 0))
if self.position.y <= self.size:
self.position.y = 2 * self.size - self.position.y
self.velocity = self.velocity.reflect(euclid.Vector2(0, 1))
elif self.position.y >= screen_height - self.size:
self.position.y = 2 * (screen_height - self.size) - self.position.y
self.velocity = self.velocity.reflect(euclid.Vector2(0, 1))
def get_wheel_lines(self):
line_length = 20.0
wheel_vec_pairs = []
# Rotate front wheels with steering angle
rot_matrix = euclid.Matrix3.new_rotate(self.steering)
for wheel in self.wheels[:2]:
pos = wheel.pos
vec = euclid.Vector2(0, -line_length / 2)
wheel_vec_pair = []
wheel_vec_pair.append(pygame.math.Vector2(rot_matrix * vec) + pos)
vec.y = line_length / 2
wheel_vec_pair.append(pygame.math.Vector2(rot_matrix * vec) + pos)
wheel_vec_pairs.append(wheel_vec_pair)
for wheel in self.wheels[2:]:
pos = wheel.pos
wheel_vec_pair = []
wheel_vec_pair.append(
pygame.math.Vector2(pos.x, pos.y - line_length / 2))
wheel_vec_pair.append(
pygame.math.Vector2(pos.x, pos.y + line_length / 2))
wheel_vec_pairs.append(wheel_vec_pair)
wheel_point_pairs = []
for pair in wheel_vec_pairs:
point_pair = []
for vec in pair:
vec_rot = self.rigid_body.relative_to_world(vec)
point_pair.append((vec_rot.x, vec_rot.y))
wheel_point_pairs.append(point_pair)
#print("("+str(vec.x)+","+str(vec.y)+" => ("+str(vec_rot.x)+","+str(vec_rot.y)+")")
return wheel_point_pairs
def neg(self):
a = (4.0, 7.0)
v = eu.Vector2(*a)
w = -v
self.assertFalse(w is v)
self.assertTrue((w.x, w.y), (-4.0, -7.0))
def test_copy(self):
a = (1.0, 2.0)
v = eu.Vector2(*a)
copied = v.__copy__()
self.assertEqual((v.x, v.y), (copied.x, copied.y))
self.assertFalse(copied is v)
def get_random_velocity(self, range_min, range_max):
new_angle = random.uniform(range_min, range_max)
new_x = math.sin(new_angle)
new_y = math.cos(new_angle)
new_vector = euclid.Vector2(new_x, new_y)
new_vector.normalize()
new_vector *= self.speed
return new_vector
def getPose(self):
#create a carPose Object,
#convert the position and headign vectors to fill the objact.
#Return the object.
#create a 2d version of the heading vector. find the relative angle of the heading vector and the vertical 'north' line on the compass.
heading = euclid.Vector2(self.headingVector.x,
self.headingVector.y).angle(
euclid.Vector2(0., 1.))
## this is a bit of a hack. not sure ecactly how this behaviour works yet. May suggest other issues in the heading coordinate system.
if self.headingVector.x > 0:
heading = -1 * heading
pose = CarPose(self.positionVector.x, self.positionVector.y, heading)
return pose
def test_deepcopy(self):
a = (1.0, 2.0)
v = eu.Vector2(*a)
copied = copy.deepcopy(v)
self.assertEqual((v.x, v.y), (copied.x, copied.y))
self.assertFalse(copied is v)
self.assertFalse(hasattr(copied, '__dict__'))
def get_random_velocity():
new_angle = random.uniform((31 * math.pi / 16), (33 * math.pi / 16))
new_x = math.sin(new_angle)
new_y = math.cos(new_angle)
new_vector = euclid.Vector2(new_x, new_y)
new_vector.normalize()
new_vector *= 20
return new_vector
def get_random_velocity():
new_angle = random.uniform(0, math.pi * 2)
new_x = math.sin(new_angle)
new_y = math.cos(new_angle)
new_vector = euclid.Vector2(new_x, new_y)
new_vector.normalize()
new_vector *= initial_velocity # pixels per second
return new_vector
def On_EnemyHurt(self, enemy):
pos = toScreenPos(enemy.feetPos)
pos[1] += 50
direction = {-1: Blood.left, 1: Blood.right}[enemy.facing]
for drop in range(0, randint(5, 20)):
bl = Blood(
pos,
direction + euclid.Vector2(randint(-2, 3), randint(-2, 3)))
self.sprites.append(bl)
def test_pickle_protocol_2(self):
a = (1.0, 2.0)
v = eu.Vector2(*a)
s = pickle.dumps(v, 2)
copied = pickle.loads(s)
self.assertEqual((v.x, v.y), (copied.x, copied.y))
self.assertFalse(copied is v)
self.assertFalse(hasattr(copied, '__dict__'))
def quitbutton_apple_generator(location):
uid = -3
size = 14
x = location[0] + int(size * 1.5) + 3
y = location[1] + int(size * 1.5) + 3
color = applecolors[random.randint(0, len(applecolors) - 1)]
velocity = 0
quitbutton = appleClass.MyApple(euclid.Vector2(x, y), (x, y), size, dtime,
uid, color, stemColor, velocity, 0)
return quitbutton
