def testNull(self):
"""Properties for null vector"""
self.assertTrue(NULL_VECTOR.is_null())
self.assertTrue(Vec2d(0, 0).is_null())
self.assertTrue(Vec2d.origin_to(Point(0,0)).is_null())
a_pt = Point(1,2)
self.assertTrue(Vec2d.from_to(a_pt, a_pt).is_null())
def testHighLevel(self):
basis0 = Vec2d(5.0, 0)
basis1 = Vec2d(0, .5)
v = Vec2d(10, 1)
self.assert_(v.convert_to_basis(basis0, basis1) == [2, 2])
self.assert_(v.projection(basis0) == (10, 0))
self.assert_(basis0.dot(basis1) == 0)
def testReverseMath(self):
v = Vec2d(111, 222)
self.assert_(1 + v == Vec2d(112, 223))
self.assert_(2 - v == [-109, -220])
self.assert_(3 * v == (333, 666))
self.assert_([222, 888] / v == [2, 4])
self.assert_([111, 222] ** Vec2d(2, 3) == [12321, 10941048])
self.assert_([-11, 78] + v == Vec2d(100, 300))
def testInplace(self):
inplace_vec = Vec2d(5, 13)
inplace_ref = inplace_vec
inplace_src = Vec2d(inplace_vec)
inplace_vec *= .5
inplace_vec += .5
inplace_vec /= (3, 6)
inplace_vec += Vec2d(-1, -1)
self.assertEquals(inplace_vec, inplace_ref)
def __init__(self, pos: Point, size: float, mass: float, velocity: Vec2d, soccer_field):
super().__init__(pos, size, velocity, velocity, Vec2d(soccer_field.playing_area.center), mass)
self.old_pos = pos
self.soccer_field = soccer_field
self.walls = soccer_field.walls
self.direction = Vec2d(20, 0)
def testMath(self):
v = Vec2d(111, 222)
self.assertEqual(v + 1, Vec2d(112, 223))
self.assert_(v - 2 == [109, 220])
self.assert_(v * 3 == (333, 666))
self.assert_(v / 2.0 == Vec2d(55.5, 111))
self.assert_(v / 2 == (55.5, 111))
self.assert_(v ** Vec2d(2, 3) == [12321, 10941048])
self.assert_(v + [-11, 78] == Vec2d(100, 300))
self.assert_(v / [10, 2] == [11.1, 111])
def testLength(self):
v = Vec2d(3, 4)
self.assert_(v.length == 5)
self.assert_(v.get_length_sqrd() == 25)
self.assert_(v.normalize_return_length() == 5)
self.assert_(v.length == 1)
v.length = 5
self.assert_(v == Vec2d(3, 4))
v2 = Vec2d(10, -2)
self.assert_(v.get_distance(v2) == (v - v2).get_length())
def testComparison(self):
int_vec = Vec2d(3, -2)
flt_vec = Vec2d(3.0, -2.0)
zero_vec = Vec2d(0, 0)
self.assert_(int_vec == flt_vec)
self.assert_(int_vec != zero_vec)
self.assert_((flt_vec == zero_vec) == False)
self.assert_((flt_vec != int_vec) == False)
self.assert_(int_vec == (3, -2))
self.assert_(int_vec != [0, 0])
self.assert_(int_vec != 5)
self.assert_(int_vec != [3, -2, -5])
def testFromVector(self):
"""Creating Vector from angle"""
import math
an_angle = AngleInRadians(value = AngleInRadians.PI_HALF)
v1 = Vec2d.from_angle(an_angle)
self.assertAlmostEquals(v1.x, 0)
self.assertAlmostEquals(v1.y, 1)
def testAngles(self):
v = Vec2d(0, 3)
self.assertEquals(v.angle, 90)
v2 = Vec2d(v)
v.rotate(-90)
self.assertAlmostEqual(v.get_angle_between(v2), 90)
v2.angle -= 90
self.assertEqual(v.length, v2.length)
self.assertEquals(v2.angle, 0)
self.assertEqual(v2, [3, 0])
self.assert_((v - v2).length <= .00001)
self.assertEqual(v.length, v2.length)
v2.rotate(300)
self.assertAlmostEquals(v.get_angle_between(v2), -60)
v2.rotate(v2.get_angle_between(v))
angle = v.get_angle_between(v2)
self.assertAlmostEquals(angle, 0)
def kick(self, direction: Vec2d, force: Vec2d):
"""Kick of a ball on a certain direction."""
# Normaliza la dirección.
direction = direction.normalized()
# Calculo de la aceleración.
acceleration = (direction * force) / self.mass
# Actualiza la velocidad.
self.velocity = acceleration
def __init__(self, team, colour: Color, number: int, pos: Point,
soccer_field):
super().__init__(pos, 15, Vec2d(0, 0), Vec2d(4, 4),
Vec2d(soccer_field.playing_area.center), 1)
self.team = team
self.colour = colour
self.number = number
self.initial_pos = pos
self.soccer_field = soccer_field
a_pt = soccer_field.playing_area.center - pos
self.direction = Vec2d(x_or_pair=(a_pt.x, a_pt.y)).normalized()
self.steering_behaviours = SteeringBehaviours(self, soccer_field.ball)
self.steering_behaviours.activated['arrive'] = True
def sum_forces(self) -> Vec2d:
force = Vec2d(0, 0)
if self.activated['seek']:
force += self.seek(self.target)
if self.activated['pursuit']:
force += self.pursuit(self.target)
if self.activated['arrive']:
force += self.arrive(self.target)
return force
def __init__ (self, a: Vec2d, b: Vec2d):
# Muro a-b
# a <-------------------------------> b
self.a = a
self.b = b
aux = Vec2d(b - a)
aux = aux.normalized()
self.normal = aux.perpendicular_normal()
def __init__(self, name: str):
super().__init__()
self.name = name
top_left_pt = OurPoint.from_tuple(Global.TOP_LEFT)
self.playing_area = Rect(
direction=CoordinatesDirection.SCREEN_DIRECTION,
pt1=top_left_pt,
pt2=OurPoint(x=top_left_pt.x + Global.WIDTH_HEIGHT[0], y=top_left_pt.y + Global.WIDTH_HEIGHT[1]))
# Walls para detectar cuándo el balón sale del terreno de juego.
self.walls = []
top_left = Vec2d(self.playing_area.topleft)
top_right = Vec2d(self.playing_area.topright)
bottom_left = Vec2d(self.playing_area.bottomleft)
bottom_right = Vec2d(self.playing_area.bottomright)
self.walls.append(Wall2d(top_left, top_right))
self.walls.append(Wall2d(top_right, bottom_right))
self.walls.append(Wall2d(top_left, bottom_left))
self.walls.append(Wall2d(bottom_left, bottom_right))
# Zonas importantes en el campo.
self.regions = {}
for i in range(0, 7):
for j in range(0, 4):
an_id = i * 4 + j
rect = Rect.from_topleft_widthheight(50 + i * 150, 50 + j * 180, 150, 180)
self.regions[an_id] = SoccerRegion(an_id, rect, self)
# Balón.
self.ball = SoccerBall(pos=self.playing_area.center, size=10, mass=2,
velocity=Vec2d(1, 10), soccer_field=self)
# Equipos
self.teams = {}
self.teams[Color.RED.value] = SoccerTeam(Color.RED.value, Color.RED, 4, self)
self.teams[Color.BLUE.value] = SoccerTeam(Color.BLUE.value, Color.BLUE, 4, self)
# Porterías.
self.goals = {}
self.goals[Color.RED.value] = SoccerGoal(Color.RED.value, Color.RED, self.playing_area.midleft, self)
self.goals[Color.BLUE.value] = SoccerGoal(Color.BLUE.value, Color.BLUE, self.playing_area.midright, self)
def arrive(self, target: Point, deceleration=FAST) -> Vec2d:
"""Similar a seek pero llegando con velocidad nula."""
to_target = Vec2d.origin_to(target - self.player.pos)
# distance to target
dist = to_target.get_length()
if dist > 25:
# Para ajustar la deceleración...
decelerationTweaker = 3
# Cálculo de la velocidad requerida.
speed = min(dist / (deceleration * decelerationTweaker), self.player.max_speed.get_length())
# velocity:
desired_velocity = to_target * speed / dist # Vec2d(to_target * speed / dist)
## FIX THIS TYPE :::
return desired_velocity - self.player.velocity
else:
return Vec2d(0, 0)
def warm_up(self):
"""Runs back and forth between the ball and a random point in the field."""
self.velocity = self.steering_behaviours.calculate()
self.pos += self.velocity
self.pos = Point(int(self.pos.x), int(self.pos.y))
if not self.is_moving():
if self.steering_behaviours.target == self.soccer_field.ball.pos:
# let's go back towards where I was.
self.steering_behaviours.target = self.initial_pos
else:
# let's go towards the ball.
self.steering_behaviours.target = self.soccer_field.ball.pos
self.direction = Vec2d(self.steering_behaviours.target -
self.pos).normalized()
def testAngle(self):
"""Do angles make sense?"""
self.assertAlmostEquals(X_UNIT_VECTOR.angle_to(Y_UNIT_VECTOR).value, AngleInRadians.PI_HALF)
self.assertAlmostEquals(Y_UNIT_VECTOR.angle_to(X_UNIT_VECTOR).value, AngleInRadians.THREE_HALFS_OF_PI)
# angle between colineal vectors is 0
a_vector = Vec2d(randint(-100, 100), randint(-100, 100))
a_vector_times_10 = a_vector * 10
self.assertAlmostEquals(a_vector.angle_to(a_vector_times_10).value, 0)
self.assertAlmostEquals(a_vector_times_10.angle_to(a_vector).value, 0)
# angle of a vector to another is equal to -1*(angle to another vector to one)
a_vector = Vec2d(randint(-100, 100), randint(-100, 100))
another_vector = Vec2d(randint(-100, 100), randint(-100, 100))
angle_one_to_the_other = a_vector.angle_to(another_vector)
angle_the_other_to_one = another_vector.angle_to(a_vector)
self.assertEqual(AngleInRadians(value = -angle_one_to_the_other.value), angle_the_other_to_one)
# some specific cases, to make for easy reading :-)
self.assertAlmostEquals(Vec2d(1,1).angle_to(Vec2d(-1,-1)).value, AngleInRadians.PI)
self.assertAlmostEquals(Vec2d(1,1).angle_to(Vec2d(-1,1)).value, AngleInRadians.PI_HALF)
self.assertAlmostEquals(Vec2d(.5,.5).angle_to(Y_UNIT_VECTOR).value, AngleInRadians.PI_HALF / 2, places=5)
def test_angle_with_positive_x(self):
self.assertEqual(Vec2d(0,0).angle_with_positive_x_axis(), AngleInRadians(0))
for _ in range(10): # repetition of test
an_int = randint(-100, 100)
if an_int > 0:
self.assertEqual(
Vec2d(0,an_int).angle_with_positive_x_axis().value, AngleInRadians.PI_HALF,
"Testing with Vec2d(0,%d)" % (an_int))
elif an_int < 0: # case with (0,0) is tested above.
self.assertEqual(
Vec2d(0,an_int).angle_with_positive_x_axis().value, AngleInRadians.THREE_HALFS_OF_PI,
"Testing with Vec2d(0,%d)" % (an_int))
# angles between vectors differing in size must coincide
for _ in range(100):
a_vector = Vec2d(random()/random(), random()/random())
another_vector = Vec2d(random()/random(), random()/random())
scale = random()/random()
orig_angle = a_vector.angle_to(another_vector)
scaled_angle = (a_vector * scale).angle_to(another_vector * scale)
self.assertAlmostEquals(orig_angle.value, scaled_angle.value, places=5)
# angles when x and y have different sign:
x = random()
if random() > 0.5:
x *= -1
y = random()
if random() > 0.5:
y *= -1
# if y < 0 => the smallest angle is for the equivalent of y > 0, so:
a_vector = Vec2d(x, y)
angle = a_vector.angle_with_positive_x_axis().value
self.assertTrue(angle >= 0, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
self.assertTrue(angle <= 2 * AngleInRadians.PI, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
if x >= 0:
if y >= 0:
# self.assertTrue(angle >= 0, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
self.assertTrue(angle <= AngleInRadians.PI_HALF, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
else:
# self.assertTrue(angle <= 0, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
self.assertTrue(angle >= AngleInRadians.THREE_HALFS_OF_PI, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
else:
if y >= 0:
# self.assertTrue(angle <= 0, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
self.assertTrue(angle >= AngleInRadians.PI_HALF and angle <= AngleInRadians.PI, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
else:
# self.assertTrue(angle >= 0, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
self.assertTrue(angle >= AngleInRadians.PI and angle <= AngleInRadians.THREE_HALFS_OF_PI, "(%.2f, %.2f), angle = %.2f" % (x,y,angle))
def reset(self, pos: Point):
"""Goes to a certain position, and stays there quietly."""
self.pos = pos
self.velocity = Vec2d(0, 0)
def testPickle(self):
testvec = Vec2d(5, .3)
testvec_str = pickle.dumps(testvec)
loaded_vec = pickle.loads(testvec_str)
self.assertEquals(testvec, loaded_vec)
def testCreationAndAccess(self):
v = Vec2d(111, 222)
self.assert_(v.x == 111 and v.y == 222)
v.x = 333
v[1] = 444
self.assert_(v[0] == 333 and v[1] == 444)
def test_scaling(self):
for _ in range(10):
a_vector = Vec2d(random()/random(), random()/random())
scale_to = randint(1, 30)
new_vector = a_vector.scaled_to_norm(new_norm = scale_to)
self.assertAlmostEqual(new_vector.norm(), scale_to)
def testUnary(self):
v = Vec2d(111, 222)
v = -v
self.assert_(v == [-111, -222])
v = abs(v)
self.assert_(v == [111, 222])
def testCross(self):
lhs = Vec2d(1, .5)
rhs = Vec2d(4, 6)
self.assert_(lhs.cross(rhs) == 4)
