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)
