def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
self._s = Vector(x2-x1, y2-y1)
self.length = sqrt((x2-x1)**2 + (y2-y1)**2)
self.slope = self._s.getSlope()
self.angle = self._s.getAngle()
def distance(e: Edge, p: Point) -> float:
# http://geomalgorithms.com/a02-_lines.html#Distance-to-Ray-or-Segment
v = Vector(e.p1, e.p2)
w = Vector(e.p1, p)
c1 = dot(w, v)
c2 = dot(v, v)
b = c1 / c2
pb = Point(e.p1.x + b * v.x, e.p1.y + b * v.y, e.p1.z + b * v.z)
if c1 <= 0:
return distance(p, e.p1)
if c2 <= c1:
return distance(p, e.p2)
return distance(p, pb)
def activate(self):
self._active = True
self.image = pygame.Surface((4, 6))
self.image.fill(opt.RED)
self.image = self.image.convert()
self.rect = self.image.get_rect()
self.pos = Vector((90, 128))
def deactivate(self):
self._active = False
self.image = pygame.Surface((4, 30))
self.image.fill(opt.RED)
self.image = self.image.convert()
self.rect = self.image.get_rect()
self.pos = Vector((90,140))
class Particle(Vector):
mass = 0
p = None
v = None
a = 0
timeToNextCollision = 0
def __init__(self, x, y, vx, vy):
self.setPosition(x, y)
self.setVelocity(vx, vy)
self.timeToNextCollision = 0
def setVelocity(self, vx, vy):
self.v = Vector(vx, vy)
def setPosition(self, x, y):
self.p = Vector(x, y)
def setTime(self, t):
self.timeToNextCollision = t
def getPosition(self):
if self.p is None:
return self.p
else:
print("position not set")
def getVelocity(self):
if self.v is None:
return self.v
else:
print("Velocity not set")
def update(self):
incident = self.v.getAngle()
class Side:
x1 = 0
y1 = 0
x2 = 0
y2 = 0
slope = 0
length = 0
angle = 0
_s = None
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
self._s = Vector(x2-x1, y2-y1)
self.length = sqrt((x2-x1)**2 + (y2-y1)**2)
self.slope = self._s.getSlope()
self.angle = self._s.getAngle()
def getX1(self):
return self.x1
def getX2(self):
return self.x2
def getY1(self):
return self.y1
def getY2(self):
return self.y2
def getLength(self):
return self.length
def getX_Intercept(self):
return (self.slope*self.x1 - self.y1)/self.slope
def getY_Intercept(self):
m = self.slope
return self.y1 - m * self.x1
def distanceFromOrigin(self):
a = self.slope
b = -1
c = self.getY_Intercept()
dist = abs(a*0 + b*0 + c)/sqrt(a*a + b*b)
return dist
def events(self):
for event in pygame.event.get():
# QUIT
if (event.type == pygame.QUIT or event.type == pygame.KEYDOWN
and event.key in [pygame.K_q, pygame.K_ESCAPE]):
self.running = False
break
# left mouse click on object (start dragging it)?
if (event.type == pygame.MOUSEBUTTONDOWN):
self.last_mouse_pos = pygame.mouse.get_pos()
left, _, _ = pygame.mouse.get_pressed()
if left:
mouse_pos = self.last_mouse_pos = pygame.mouse.get_pos()
debug("mouse down at: %s" % str(pygame.mouse.get_pos()))
for i, s in enumerate(self.all_sprites):
r = s.rect
if r.collidepoint(*mouse_pos):
debug("Click at %s on %s %d", str(mouse_pos),
s.__class__.__name__, s.oid)
self.moving_object = s
# left mouse released (stop dragging)?
if (event.type == pygame.MOUSEBUTTONUP):
self.moving_object = None
# drag sensor
if self.moving_object:
pos = Vector(pygame.mouse.get_pos())
self.moving_object.pos = pos
# commands keys --------------------
if (event.type == pygame.KEYDOWN):
k, p, s = event.key, pygame, self
if k in [p.K_s]: s._add_sensor()
elif k in [p.K_c]: s._add_car()
elif k in [p.K_l]: s._do_log()
elif k in [p.K_b]: s._do_backup()
elif k in [p.K_r]: s._do_restore()
elif k in [p.K_p]: s._do_park()
elif k in [p.K_u]: s._do_unpark()
elif k in [p.K_x]: s._do_random_park_unpark()
elif k in [p.K_PLUS, p.K_EQUALS]:
s._do_change_random_interval(factor=2)
elif k in [p.K_MINUS, p.K_UNDERSCORE]:
s._do_change_random_interval(factor=.5)
elif k in [p.K_h, p.K_QUESTION]:
s._do_help()
elif k in [p.K_t]:
s._add_stairs()
else:
error("No command bound to '%s' key.", event.unicode)
def __init__(self, world, pos):
self._layer = opt.STAIRS_LAYER
self.groups = world.all_sprites, world.stairs
pygame.sprite.Sprite.__init__(self, self.groups)
self.oid = Stairs.oid
Stairs.oid += 1
self.world = world
self.image = pygame.Surface((100, 30))
self.image.fill(opt.GRAY)
self.image = self.image.convert()
self.rect = self.image.get_rect()
self.pos = Vector(pos)
def distance(e1: Edge, e2: Edge) -> float:
# http://geomalgorithms.com/a07-_distance.html#dist3D_Segment_to_Segment()
SMALL_NUM = 0.00000001
u, v, w = Vector(e1.p1, e1.p2), Vector(e2.p1, e2.p2), Vector(e2.p1, e1.p1)
a, b, c, d, e = dot(u, u), dot(u, v), dot(v, v), dot(u, w), dot(v, w)
D = a * c - b * b
sc, sN, sD = D, D, D
tc, tN, tD = D, D, D
if D < SMALL_NUM:
sN, sD = 0.0, 1.0
tN, tD = e, c
else:
sN, tN = (b * e - c * d), (a * e - b * d)
if sN < 0.0:
sN, tN, tD = 0.0, e, c
elif sN > sD:
sN, tN, tD = sD, e + b, c
if tN < 0.0:
tN = 0.0
if -d < 0.0:
sN = 0.0
elif -d > a:
sN = sD
else:
sN, sD = -d, a
elif tN > tD:
tN = tD
if (-d + b) < 0.0:
sN = 0
elif (-d + b) > a:
sN = sD
else:
sN, sD = (-d + b), a
sc = sN / sD
tc = tN / tD
dP = w + (u * sc) - (v * tc)
return dP.length()
def __init__(self, world, pos):
self._layer = opt.CAR_LAYER
self.groups = world.all_sprites, world.cars
pygame.sprite.Sprite.__init__(self, self.groups)
self.oid = Car.oid
Car.oid += 1
self.world = world
self.image = pygame.Surface((30, 30))
self.image.fill(opt.YELLOW)
self.image = self.image.convert()
self.rect = self.image.get_rect()
self.pos = Vector(pos)
self.move_target = None
self._state = opt.WAITING
self.sensor = None
def __init__(self, world, pos):
self._layer = opt.CAR_SENSOR_LAYER
self.groups = world.all_sprites, world.sensors
pygame.sprite.Sprite.__init__(self, self.groups)
self.oid = CarSensor.oid
CarSensor.oid += 1
self.world = world
self.image = pygame.Surface((30, 30))
self.image.fill(opt.GREEN)
self.image = self.image.convert()
self.rect = self.image.get_rect()
self.pos = Vector(pos)
self._active = False
self.car = None
self.reserved = False
self.access_log = dict()
def __init__(self, world, pos, dim, color):
self._layer = opt.ENTRANCE_LAYER
self.groups = world.all_sprites, world.entrance
pygame.sprite.Sprite.__init__(self, self.groups)
self.oid = Entrance.oid
Entrance.oid += 1
self.world = world
self.image = pygame.Surface(dim)
self.image.fill(color)
self.image = self.image.convert()
self.rect = self.image.get_rect()
self.pos = Vector(pos)
self._active = False
self.car = None
self.reserved = False
self.access_log = dict()
self.activate
def generateRandomPointRational(self):
if len(self.verts) < 1:
_side = Vector(50, 50)
_length = _side.getLength()
lenGen = rn.random * _length / 4 + 0.75 * _length
angleGen = 0
tempVert = Vector(0, 0)
tempVert = Vector.createP(tempVert, lenGen, angleGen)
self.verts.append(tempVert)
else:
lv = len(self.verts)
recentAngle = self.verts[lv - 1].getAngle()
angleGen = (360 / self.noOfVert) + recentAngle
lenGen = self.verts[lv - 1].getLength()
tempVert = Vector(0, 0)
tempVert = Vector.createP(tempVert, lenGen, angleGen)
self.verts.append(tempVert)
def test_create_from_untyped_list(self):
l = [1, 5 / 7, 6.7]
v = Vector(l)
self.assertIsInstance(v, Vector)
self.assertSequenceEqual(v, to_fraction(l), Fraction)
def test_create_from_integer_list(self):
l = [1, 1, 1]
v = Vector(l)
self.assertIsInstance(v, Vector)
self.assertSequenceEqual(v, to_fraction(l), Fraction)
def test_inner_product(self):
self.assertEqual(-30, Vector(3, fill=2).inner_prod(Vector(3, fill=-5)))
def test_create_from_vector(self):
l = [1, 5 / 7, 6.7]
v1 = Vector(l)
v2 = Vector(v1)
self.assertIsInstance(v2, Vector)
self.assertSequenceEqual(v1, v2, Fraction)
def setUp(self):
self.l = [1, 5 / 7, 6.7]
self.l_to_fraction = to_fraction(self.l)
self.v = Vector(self.l)
def unpark_from_sensor(self, sensor):
self._state = opt.LEAVING
self.move_target = None
self.move_step = Vector(opt.WIDTH - self.pos[0], 0) / 50.
def test_construction_from_specified_dim_and_fill(self):
self.assertEqual("<1, 1, 1, 1, 1>", str(Vector(5, fill=1)))
def setPosition(self, x, y):
self.p = Vector(x, y)
def test_set_item(self):
v = Vector(self.v)
index = 0
value = 5
v[index] = value
self.assertEqual(v[index], Fraction(value))
def events(self):
for event in pygame.event.get():
# QUIT
if (event.type == pygame.QUIT or event.type == pygame.KEYDOWN
and event.key in [pygame.K_q, pygame.K_ESCAPE]):
self.running = False
break
# RESIZE
if event.type == pygame.VIDEORESIZE:
width, height = event.size
if (width < opt.WIDTH or height < opt.HEIGHT):
width = opt.WIDTH
height = opt.HEIGHT
self.screen = pygame.display.set_mode(
(width, height),
pygame.RESIZABLE | pygame.HWSURFACE | pygame.DOUBLEBUF)
self.current_background = pygame.transform.scale(
self.original_background, (width, height))
# left mouse click on object (start dragging it)?
if (event.type == pygame.MOUSEBUTTONDOWN):
self.last_mouse_pos = pygame.mouse.get_pos()
left, _, _ = pygame.mouse.get_pressed()
if left:
mouse_pos = self.last_mouse_pos = pygame.mouse.get_pos()
debug("mouse down at: %s" % str(pygame.mouse.get_pos()))
for i, s in enumerate(self.all_sprites):
r = s.rect
if r.collidepoint(*mouse_pos):
debug("Click at %s on %s %d", str(mouse_pos),
s.__class__.__name__, s.oid)
self.moving_object = s
# left mouse released (stop dragging)?
if (event.type == pygame.MOUSEBUTTONUP):
self.moving_object = None
# drag sensor
if self.moving_object:
pos = Vector(pygame.mouse.get_pos())
self.moving_object.pos = pos
# commands keys --------------------
if (event.type == pygame.KEYDOWN):
k, p, s = event.key, pygame, self
if k in [p.K_s]: s._add_sensor()
elif k in [p.K_c]: s._add_car()
elif k in [p.K_l]: s._do_log()
elif k in [p.K_b]: s._do_backup()
elif k in [p.K_r]: s._do_restore()
elif k in [p.K_p]: s._do_park()
elif k in [p.K_u]: s._do_unpark()
elif k in [p.K_x]: s._do_random_park_unpark()
elif k in [p.K_PLUS, p.K_EQUALS]:
s._do_change_random_interval(factor=2)
elif k in [p.K_MINUS, p.K_UNDERSCORE]:
s._do_change_random_interval(factor=.5)
elif k in [p.K_h, p.K_QUESTION]:
s._do_help()
elif k in [p.K_t]:
s._add_stairs()
else:
error("No command bound to '%s' key.", event.unicode)
def test_set_slice(self):
v = Vector(self.v)
index = slice(1, -1)
value = [5, 7 / 9]
v[index] = value
self.assertSequenceEqual(v[index], to_fraction(value), Fraction)
def test_create_from_nothing(self):
v = Vector()
self.assertIsInstance(v, Vector)
self.assertEqual(len(v), 0)
def test_construction_from_list(self):
self.assertEqual("<-6, 27, 4.3, 16, -81.95>",
str(Vector([-6, 27, 4.3, 16, -81.95])))
def test_construction_from_args(self):
self.assertEqual("<-6, 27, 4.3, 16, -81.95>",
str(Vector(-6, 27, 4.3, 16, -81.95)))
def test_to_list_conversion(self):
self.assertEqual([1, 2, 3, 4, 5], Vector(1, 2, 3, 4, 5).to_list())
def setVelocity(self, vx, vy):
self.v = Vector(vx, vy)
def test_construction_from_specified_dim_no_fill(self):
self.assertEqual("<0, 0, 0, 0, 0>", str(Vector(5)))
