def _accelerate_ai(self, target): dist = vectors.distance(self.pos, target) if dist > self.max_velocity: self.velocity = vectors.move_to_vector(vectors.angle(self.pos, target), self.max_velocity) else: self.velocity = vectors.move_to_vector(vectors.angle(self.pos, target), dist)
def _bounce_one(a1, a2): # Bounces a1 dir_angle = vectors.angle(a2.pos, a1.pos) vel_angle = vectors.angle(a1.velocity) # If they are head on then we want to swivel them a little if vectors.bound_angle(dir_angle[0]+180) == vel_angle[0]: dir_angle[0] = vectors.bound_angle(dir_angle[0] + 40) # Keep trying distances further and further apart until they're # not going to be overlapping any more overlapping = True dist = vectors.total_velocity(a1.velocity) a2_rect = (a2.pos[0], a2.pos[1], a2.size[0], a2.size[1]) while overlapping: new_pos = vectors.add_vectors(a1.pos, vectors.move_to_vector( dir_angle, dist )) new_rect = (new_pos[0], new_pos[1], a1.size[0], a1.size[1]) if not geometry.rect_collision(new_rect, a2_rect, True): overlapping = False dist += 1 # Add a bit to be safe new_pos = vectors.add_vectors(a1.pos, vectors.move_to_vector( dir_angle, dist + vectors.total_velocity(a1.velocity) )) a1.pos = new_pos
def _bounce_one(a1, a2): # Bounces a1 dir_angle = vectors.angle(a2.pos, a1.pos) vel_angle = vectors.angle(a1.velocity) # If they are head on then we want to swivel them a little if vectors.bound_angle(dir_angle[0] + 180) == vel_angle[0]: dir_angle[0] = vectors.bound_angle(dir_angle[0] + 40) # Keep trying distances further and further apart until they're # not going to be overlapping any more overlapping = True dist = vectors.total_velocity(a1.velocity) a2_rect = (a2.pos[0], a2.pos[1], a2.size[0], a2.size[1]) while overlapping: new_pos = vectors.add_vectors(a1.pos, vectors.move_to_vector(dir_angle, dist)) new_rect = (new_pos[0], new_pos[1], a1.size[0], a1.size[1]) if not geometry.rect_collision(new_rect, a2_rect, True): overlapping = False dist += 1 # Add a bit to be safe new_pos = vectors.add_vectors( a1.pos, vectors.move_to_vector(dir_angle, dist + vectors.total_velocity(a1.velocity))) a1.pos = new_pos
def _accelerate_ai(self, target): dist = vectors.distance(self.pos, target) if dist > self.max_velocity: self.velocity = vectors.move_to_vector( vectors.angle(self.pos, target), self.max_velocity) else: self.velocity = vectors.move_to_vector( vectors.angle(self.pos, target), dist)
def get_offset_pos(self, use_effect_offset=False): """Gets the drawing position relative to the centre of their actor""" if use_effect_offset: base_offset = self.get_offset_pos() own_offset = vectors.move_to_vector( angle=vectors.add_vectors(self._effect_offset_angle, self.actor.facing), distance=self._effect_offset_distance) return vectors.add_vectors(base_offset, own_offset) else: return vectors.move_to_vector(angle=vectors.add_vectors( self._img_offset_angle, self.actor.facing), distance=self._img_offset_distance)
def get_offset_pos(self, use_effect_offset=False): """Gets the drawing position relative to the centre of their actor""" if use_effect_offset: base_offset = self.get_offset_pos() own_offset = vectors.move_to_vector( angle = vectors.add_vectors(self._effect_offset_angle, self.actor.facing), distance = self._effect_offset_distance ) return vectors.add_vectors(base_offset, own_offset) else: return vectors.move_to_vector( angle = vectors.add_vectors(self._img_offset_angle, self.actor.facing), distance = self._img_offset_distance )
def test_move_to_vector(self): vals = ( ((0, 0), 10, (0, -10, 0)), # Up ((90, 0), 10, (10, 0, 0)), # Right ((180, 0), 10, (0, 10, 0)), # Down ((270, 0), 10, (-10, 0, 0)), # Left ((45, 0), 10, (7.07, -7.07, 0)), # Up - right ((135, 0), 10, (7.07, 7.07, 0)), # Down - right ((225, 0), 10, (-7.07, 7.07, 0)), # Down - left ((315, 0), 10, (-7.07, -7.07, 0)), # Up - left # Now all the above with a 45 degree upward tilt too # ([0,45], 10, [0,-10,-7.07]),# Up # ([90,45], 10, [10,0,0]),# Right # ([180,45], 10, [0,10,0]),# Down # ([270,0], 10, [-10,0,0]),# Left # # ([45,45], 10, [7.07, -7.07, 0]),# Up - right # ([135,45], 10, [7.07, 7.07, 0]),# Down - right # ([225,45], 10, [-7.07, 7.07, 0]),# Down - left # ([315,45], 10, [-7.07, -7.07, 0]),# Up - left ) for angle, distance, expected in vals: answer = vectors.move_to_vector(angle, distance) try: self.assertAlmostEqual(answer[0], expected[0], places=2) self.assertAlmostEqual(answer[1], expected[1], places=2) self.assertAlmostEqual(answer[2], expected[2], places=2) except Exception as e: print("\n\nAngle: %s, Distance: %s, Expected: %s, Got: %s" % (angle, distance, expected, answer)) raise
def generate_bullet(self, target): # Set correct origin offset_angle = vectors.bound_angle( vectors.add_vectors(self._effect_offset_angle, self.facing)) origin_pos = vectors.add_vectors( self.get_offset_pos(use_effect_offset=True), self.actor.pos) # Get actual velocity we'll be using if type(target) == list or type(target) == tuple: direction = vectors.angle(origin_pos, target) target_pos = target else: direction = vectors.angle(origin_pos, target.pos) target_pos = target.pos velocity = vectors.move_to_vector(direction, self.bullet['velocity']) velocity[2] = math_lib.calc_trajectory( 0.1, vectors.distance(origin_pos, target_pos), self.bullet['velocity']) the_bullet = bullets.Shell( pos=origin_pos, velocity=velocity, image=self.bullet['image'], size=self.bullet['size'], blast_radius=self.bullet['blast_radius'], damage=self.bullet['damage'], dissipation_func=self.bullet.get('dissipation_func', "linear"), ) self.actor.bullets.append(the_bullet)
def generate_bullet(self, target): # Set correct origin offset_angle = vectors.bound_angle( vectors.add_vectors(self._effect_offset_angle, self.facing) ) origin_pos = vectors.add_vectors(self.get_offset_pos(use_effect_offset=True), self.actor.pos) # Get actual velocity we'll be using if type(target) == list or type(target) == tuple: direction = vectors.angle(origin_pos, target) target_pos = target else: direction = vectors.angle(origin_pos, target.pos) target_pos = target.pos velocity = vectors.move_to_vector(direction, self.bullet['velocity']) velocity[2] = math_lib.calc_trajectory(0.1, vectors.distance(origin_pos, target_pos), self.bullet['velocity']) the_bullet = bullets.Shell( pos=origin_pos, velocity=velocity, image = self.bullet['image'], size = self.bullet['size'], blast_radius = self.bullet['blast_radius'], damage = self.bullet['damage'], dissipation_func = self.bullet.get('dissipation_func', "linear"), ) self.actor.bullets.append(the_bullet)
def test_move_to_vector(self): vals = ( ((0,0), 10, (0,-10,0)),# Up ((90,0), 10, (10,0,0)),# Right ((180,0), 10, (0,10,0)),# Down ((270,0), 10, (-10,0,0)),# Left ((45,0), 10, (7.07, -7.07, 0)),# Up - right ((135,0), 10, (7.07, 7.07, 0)),# Down - right ((225,0), 10, (-7.07, 7.07, 0)),# Down - left ((315,0), 10, (-7.07, -7.07, 0)),# Up - left # Now all the above with a 45 degree upward tilt too # ([0,45], 10, [0,-10,-7.07]),# Up # ([90,45], 10, [10,0,0]),# Right # ([180,45], 10, [0,10,0]),# Down # ([270,0], 10, [-10,0,0]),# Left # # ([45,45], 10, [7.07, -7.07, 0]),# Up - right # ([135,45], 10, [7.07, 7.07, 0]),# Down - right # ([225,45], 10, [-7.07, 7.07, 0]),# Down - left # ([315,45], 10, [-7.07, -7.07, 0]),# Up - left ) for angle, distance, expected in vals: answer = vectors.move_to_vector(angle, distance) try: self.assertAlmostEqual(answer[0], expected[0], places=2) self.assertAlmostEqual(answer[1], expected[1], places=2) self.assertAlmostEqual(answer[2], expected[2], places=2) except Exception as e: print("\n\nAngle: %s, Distance: %s, Expected: %s, Got: %s" % (angle, distance, expected, answer)) raise
def run_ai(self): if self.micro_orders == []: cmd, pos, target = self.current_order else: cmd, pos, target = self.micro_orders[0] self._attack_ai() if cmd == "stop" or cmd == "hold position": self.velocity = [0,0,0] if target == 0: self.next_order() elif cmd == "move" or cmd == "reverse": dist = vectors.distance(self.pos, pos) self.velocity = vectors.move_to_vector(vectors.angle(self.pos, pos), self.max_velocity) if dist <= vectors.total_velocity(self.velocity): self.pos = pos self.velocity = [0,0,0] self.next_order() else: raise Exception("No handler for cmd %s (pos: %s, target: %s)" % (cmd, pos, target))
def get_rotated_offset(self, angle): if self.centre_offset == (0, 0): return 0, 0 # Get the actual angle to use offset_angle = vectors.bound_angle( vectors.add_vectors(self.centre_offset[1], angle)) return vectors.move_to_vector(offset_angle, self.centre_offset[0])
def get_rotated_offset(self, angle): if self.centre_offset == (0, 0): return 0, 0 # Get the actual angle to use offset_angle = vectors.bound_angle( vectors.add_vectors(self.centre_offset[1], angle) ) return vectors.move_to_vector(offset_angle, self.centre_offset[0])
def _bounce_both(a1, a2): # These are the angles directly away from each other angle1 = vectors.angle(a2.pos, a1.pos) angle2 = vectors.angle(a1.pos, a2.pos) vel_angle1 = vectors.angle(a1.velocity) vel_angle2 = vectors.angle(a2.velocity) # If they are head on then we want to swivel them a little if vel_angle1[0] == angle2[0] and vel_angle2[0] == angle1[0]: angle1[0] = vectors.bound_angle(angle1[0] + 20) angle2[0] = vectors.bound_angle(angle2[0] + 20) # Keep trying distances further and further apart until they're # not going to be overlapping any more overlapping = True dist_multiplier = 0.1 while overlapping: dist_multiplier += 0.1 new_pos1 = vectors.add_vectors( a1.pos, vectors.move_to_vector(angle1, max(a1.size) * dist_multiplier)) new_pos2 = vectors.add_vectors( a2.pos, vectors.move_to_vector(angle2, max(a2.size) * dist_multiplier)) new_rect1 = (new_pos1[0], new_pos1[1], a1.size[0], a1.size[1]) new_rect2 = (new_pos2[0], new_pos2[1], a2.size[0], a2.size[1]) if not geometry.rect_collision(new_rect1, new_rect2): overlapping = False a1.pos = new_pos1 a2.pos = new_pos2
def _bounce_both(a1, a2): # These are the angles directly away from each other angle1 = vectors.angle(a2.pos, a1.pos) angle2 = vectors.angle(a1.pos, a2.pos) vel_angle1 = vectors.angle(a1.velocity) vel_angle2 = vectors.angle(a2.velocity) # If they are head on then we want to swivel them a little if vel_angle1[0] == angle2[0] and vel_angle2[0] == angle1[0]: angle1[0] = vectors.bound_angle(angle1[0] + 20) angle2[0] = vectors.bound_angle(angle2[0] + 20) # Keep trying distances further and further apart until they're # not going to be overlapping any more overlapping = True dist_multiplier = 0.1 while overlapping: dist_multiplier += 0.1 new_pos1 = vectors.add_vectors(a1.pos, vectors.move_to_vector( angle1, max(a1.size) * dist_multiplier )) new_pos2 = vectors.add_vectors(a2.pos, vectors.move_to_vector( angle2, max(a2.size) * dist_multiplier )) new_rect1 = (new_pos1[0], new_pos1[1], a1.size[0], a1.size[1]) new_rect2 = (new_pos2[0], new_pos2[1], a2.size[0], a2.size[1]) if not geometry.rect_collision(new_rect1, new_rect2): overlapping = False a1.pos = new_pos1 a2.pos = new_pos2
def generate_bullet(self, target): if type(target) == list or type(target) == tuple: direction = vectors.angle(self.actor.pos, target) target_pos = target else: direction = vectors.angle(self.actor.pos, target.pos) target_pos = target.pos velocity = vectors.move_to_vector(direction, self.bullet['velocity']) velocity[2] = math_lib.calc_trajectory(0.1, vectors.distance(self.actor.pos, target_pos), self.bullet['velocity']) the_bullet = bullets.Shell( pos=self.actor.pos, velocity=velocity, image = self.bullet['image'], size = self.bullet['size'], blast_radius = self.bullet['blast_radius'], damage = self.bullet['damage'], dissipation_func = self.bullet.get('dissipation_func', "linear"), ) self.actor.bullets.append(the_bullet)