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