def boundarycompute(self):
try:
return self.boundary
except:
if self[0].str2[6:9] != 'GLY':
atoms = self.findatoms([" N "," C "," CA "," O "," OT1", " CB "])
else:
atoms = self.findatoms([" N "," C "," CA "," O "," OT1", " HA2"])
atoms.remove(0)
posterm = vector.Nlocation(atoms[1].coords(),atoms[2].coords(),atoms[3].coords())
axis = vector.translate(vector.minus(atoms[0].coords()))(posterm)
N1 = vector.unit(axis)
length = vector.norm(axis)
N2 = vector.unit(vector.translate(vector.minus(atoms[2].coords()))(atoms[4].coords()))
self.boundary = [atoms[0].coords(), N1, N2, length]
return self.boundary
def object_collision(sprite1, sprite2):
normal = [sprite1.origin[0] - sprite2.origin[0], sprite1.origin[1] - sprite2.origin[1]]
unit_normal = vector.unit(normal)
unit_tangent = [-unit_normal[1], unit_normal[0]]
neg_unit_normal = vector.times(-1, unit_normal)
sprite1.pos = vector.plus(sprite1.pos, unit_normal)
sprite1.set_position(sprite1.pos)
sprite2.pos = vector.plus(sprite2.pos, neg_unit_normal)
sprite2.set_position(sprite2.pos)
v1n = vector.dotp(unit_normal, sprite1.speed)
v1t = vector.dotp(unit_tangent, sprite1.speed)
v2n = vector.dotp(unit_normal, sprite2.speed)
v2t = vector.dotp(unit_tangent, sprite2.speed)
u1n = (v1n * (sprite1.mass - sprite2.mass) + 2 * sprite2.mass * v2n) / (sprite1.mass + sprite2.mass)
u2n = (v2n * (sprite2.mass - sprite1.mass) + 2 * sprite1.mass * v1n) / (sprite1.mass + sprite2.mass)
sprite1_tangent = vector.times(v1t, unit_tangent)
sprite1_normal = vector.times(u1n, unit_normal)
sprite2_tangent = vector.times(v2t, unit_tangent)
sprite2_normal = vector.times(u2n, unit_normal)
sprite1.speed = vector.plus(sprite1_tangent, sprite1_normal)
sprite2.speed = vector.plus(sprite2_tangent, sprite2_normal)
def __init__(self, terrain):
pos = terrain.start.origin
tiles = terrain.surrounding_tiles(terrain.start, multiplier=2)
for tile in tiles:
if tile.color == colors['road']:
direction = vector.unit(
vector.distance(tile.pos, terrain.start.pos))
super().__init__(pos, 1, direction, 10, 20, colors['blue'])
def d(t):
currentPoint = Wmap.ev(0)[0]
currentLocationOnRnew = Rnew.projectOntoAxis(currentPoint)
for x in pointsOnWmap:
thisLocationOnRnew = Rnew.projectOntoAxis(x)
if thisLocationOnRnew >= currentLocationOnRnew:
if thisLocationOnRnew <= t:
currentLocationOnRnew = thisLocationOnRnew
currentPoint = x
return vector.vectorToAngle(vector.unit(vector.translate(vector.minus(Rnew.ev(currentLocationOnRnew)[0]))(currentPoint)))
def circleArc(center, start, end):
radToStart = vector.translate(vector.minus(center))(start)
radToEnd = vector.translate(vector.minus(center))(end)
radiusSquared = vector.norm(radToStart)*vector.norm(radToEnd)
radius = math.sqrt(radiusSquared)
innerProductValue = vector.innerproduct(radToStart, radToEnd)
angle = math.acos(innerProductValue/radiusSquared)
firstUnitRadial = vector.unit(radToStart)
secondUnitRadial = vector.unit(vector.translate(vector.scale(radToStart,-innerProductValue/radiusSquared))(radToEnd))
def CN(t):
point = vector.translate(center)(vector.translate(vector.scale(firstUnitRadial,radius*math.cos(t/radius)))(vector.scale(secondUnitRadial,radius*math.sin(t/radius))))
tangent = vector.translate(vector.scale(firstUnitRadial,-math.sin(t/radius)))(vector.scale(secondUnitRadial,math.cos(t/radius)))
output = [point,tangent]
#output.append([math.cos(t/radius),math.sin(t/radius),0])
return output
return TwistingAxis(angle*radius,CN)
def boundarycompute(self):
try:
return self.boundary
except:
if self[0].str2[6:9] != 'GLY':
atoms = self.findatoms(
[" N ", " C ", " CA ", " O ", " OT1", " CB "])
else:
atoms = self.findatoms(
[" N ", " C ", " CA ", " O ", " OT1", " HA2"])
atoms.remove(0)
posterm = vector.Nlocation(atoms[1].coords(), atoms[2].coords(),
atoms[3].coords())
axis = vector.translate(vector.minus(atoms[0].coords()))(posterm)
N1 = vector.unit(axis)
length = vector.norm(axis)
N2 = vector.unit(
vector.translate(vector.minus(atoms[2].coords()))(
atoms[4].coords()))
self.boundary = [atoms[0].coords(), N1, N2, length]
return self.boundary
def bounce2(self, p2):
""" More complicated bounce, should give better angles.
Takes in the particle it is bouncing against and updates its speed too """
avgSpeed = vector.scale(vector.absAdd(self.speed, p2.speed), 0.5) # Average speed
# Find the normalised vector from p1 to p2
n = vector.unit(vector.subtract(self.position, p2.position))
self.speed = vector.multiply(n, avgSpeed)
p2.speed = vector.scale(vector.multiply(n, avgSpeed), -1)
self.limitSpeed()
p2.limitSpeed()
def segment(start, end):
startToEnd = vector.translate(vector.minus(start))(end)
distance = vector.norm(startToEnd)
try:
tng = vector.unit(startToEnd)
def CN(t):
output = [vector.translate(start)(vector.scale(tng,t)),tng]
#output.append(normal)
return output
except:
def CN(t):
output = [start, [0,0,0]]
return TwistingAxis(distance, CN)
def bounce2(self, p2):
""" More complicated bounce, should give better angles.
Takes in the particle it is bouncing against and updates its speed too """
avgSpeed = vector.scale(vector.absAdd(self.speed, p2.speed),
0.5) # Average speed
# Find the normalised vector from p1 to p2
n = vector.unit(vector.subtract(self.position, p2.position))
self.speed = vector.multiply(n, avgSpeed)
p2.speed = vector.scale(vector.multiply(n, avgSpeed), -1)
self.limitSpeed()
p2.limitSpeed()
def smoothedPieceWiseLinearFullFunctionality(points, mapFromSpaceToTime, Wnew, smoothingFactor = 0.33):
if len(points) < 2:
print("Error: only " + str(len(points)) + " points supplied to smoothedPieceWiseLinear")
return
currentPoints = copy.deepcopy(points)
numPoints = len(currentPoints)
attachElements = [cutSegment(points[0],points[1],0,smoothingFactor)]
for i in range(0,numPoints - 2):
lastToPivot = vector.translate(vector.minus(points[i]))(points[i+1])
pivotToNext = vector.translate(vector.minus(points[i+1]))(points[i+2])
angle = vector.innerproduct(lastToPivot, pivotToNext)/(vector.norm(lastToPivot)*vector.norm(pivotToNext))
collinear = (abs(angle) < 0.001)
if collinear:
attachElements.append(cutSegment(points[i],points[i+1],smoothingFactor,1))
attachElements.append(cutSegment(points[i+1],points[i+2],1,smoothingFactor))
else:
attachElements.append(cutSegment(points[i],points[i+1],smoothingFactor,1-smoothingFactor))
attachElements.append(circleArcAroundPivotClosestPieces(points[i+1],points[i],points[i+2],smoothingFactor))
attachElements.append(cutSegment(points[-2],points[-1],smoothingFactor,1))
def iteratedAttach(start, end):
if start < end:
midpoint = (start + end)/2
iteratedAttach(start, midpoint)
iteratedAttach(midpoint + 1, end)
attachElements[start].attachPartial(1, attachElements[midpoint + 1])
iteratedAttach(0, len(attachElements)-1)
Wmap = attachElements[0]
produceN2 = lambda x : vector.unit(vector.orthogonalComponent(vector.translate(vector.minus(Wnew.ev(mapFromSpaceToTime(x[0]))[0]))(x[0]),x[1]))
appendN2 = lambda x: [x[0],x[1],produceN2(x)]
Wmap.CN = compose(appendN2,Wmap.CN)
return [Wmap, Wnew, lambda t: mapFromSpaceToTime(Wmap.ev(t)[0])]
def findActualEndPoint(vec):
unitVec = vector.unit(vec)
return vector.translate(pivot)(vector.scale(vector.unit(vec),smallerNorm*smoothingFactor))
def grab(self):
mouse = pygame.mouse.get_pos()
#if self.rect.collidepoint(mouse):
direction_vector = [mouse[0] - self.origin[0], mouse[1] - self.origin[1]]
unit_direction = vector.unit(direction_vector)
self.speed = vector.plus(self.speed, unit_direction)
