def alignment(self, others: Iterable[Turtle]):
angles = [other.heading() for other in self.neighbors(others, 40)]
if angles:
avg_angle = sum(angles) / len(angles)
return Vec2D(math.cos(math.radians(avg_angle)), math.sin(math.radians(avg_angle)))
else:
return Vec2D(0,0)
def __init__(self):
self.root = tk.Tk()
self.canvas = tk.Canvas(self.root,
width=kCanvasWidth,
height=kCanvasHeight,
bg='gray')
self.canvas.pack()
self.root.bind('<KeyPress>', self.update)
self.valid_pos = set(
map(lambda t: Vec2D(*t),
itertools.product(range(kGridWidth),
range(kGridHeight)))) # 有效网格坐标集合
self.rand_pos = lambda w, h: Vec2D(random.randint(
0, w - 1), random.randint(0, h - 1)) # 生成随机网格坐标
self.food = (None, self.canvas.create_oval(0, 0, 0, 0, fill='green')
) # 食物：(网格坐标, 图形对象)
self.snake_dir = None # 蛇头方向：Vec2D(x, y)
self.snake_bodys = [] # 蛇身：[(网格坐标,图形对象), ...]
self.scene = kSceneStart # 场景编号
self.score = 0 # 分数
self.update_funcs = [
self.update_gamestart, self.update_gameplay, self.update_gameover
] # 场景更新函数
self.next_update = self.root.after(kUpdateDelay,
self.update) # 延迟执行下一次更新
def drop(self):
pos = self.pos
falling = True
while falling:
pos = pos + Vec2D(0, 1)
falling = self.check(pos, self.shapetype)
self.pos = pos + Vec2D(0, -1)
def main():
global s, sun
s = Screen()
s.setup(800, 600, 50, 50)
s.screensize(750, 550)
createPlanetShape()
## setup gravitational system
s.setworldcoordinates(-hfw*4/3, -hfw, hfw*4/3, hfw)
gs = GravSys()
sun = Star(mS, Vec2D(0.,0.), Vec2D(0.,0.), gs, "circle")
sun.color("yellow")
sun.turtlesize(1.8)
sun.pu()
earth = Star(mE, Vec2D(rE,0.), Vec2D(0.,vE), gs, "planet")
earth.pencolor("green")
earth.shapesize(0.8)
mercury = Star(mME, Vec2D(0., perihelME), Vec2D(-perihelvME, 0),
gs, "planet")
mercury.pencolor("blue")
mercury.shapesize(0.5)
venus = Star(mVE, Vec2D(-rVE, 0.), Vec2D(0., -vVE), gs, "planet")
venus.pencolor("blue")
venus.shapesize(0.65)
mars = Star(mMA, Vec2D(0., -rMA), Vec2D(vMA, 0.), gs, "planet")
mars.pencolor("blue")
mars.shapesize(0.45)
gs.init()
gs.start()
return "Done!"
def main():
screen = Screen()
turtle = Turtle()
myPoints = [Vec2D(-200, -100), Vec2D(0, 200), Vec2D(200, -100)]
sierpinski(myPoints, 5, turtle)
turtle.hideturtle()
screen.exitonclick()
def __init__(self, canvas=None):
self.canvas = canvas or Canvas(self.DEFAULT_WIDTH, self.DEFAULT_HEIGHT)
self.origin = Vec2D(self.canvas.width // 2, self.canvas.height // 2)
self.position = Vec2D(0.0, 0.0)
self.heading = 0.0
self.pendown = True
self.canvas.begin_path()
self.canvas.move_to(self.origin[0], self.origin[1])
def __init__(self):
super(random1, self).__init__()
self.addBoundary(boundary.RectangularBoundary(500, 500))
for i in range(10):
pos = Vec2D(random.randrange(-200, 200),
random.randrange(-200, 200))
vel = Vec2D(random.randrange(-100, 100, 1),
random.randrange(-100, 100, 1)) * 0.005
self.append(Particle(pos, vel))
def main():
## setup gravitational system
gs = GravSys()
sun1 = Star(400000, Vec2D(-150, 0), Vec2D(0, -80), gs, "circle")
sun1.color("red")
sun2 = Star(400000, Vec2D(150, 0), Vec2D(0, 80), gs, "circle")
sun2.color("orange")
Screen().tracer(False)
gs.init()
gs.start()
def __init__(self):
global width, height
self.position = Vec2D(width / 2, height / 2)
self.velocity = Vec2D(0.3, 0.3)
self.radius = 10
self.color = (255, 255, 255)
def turn(n):
if not (type(n) is Direction.Up):
t._rotate(n * -1)
else:
if n == Direction.Up:
t._orient = Vec2D(0, 1.0)
if n == Direction.Left:
t._orient = Vec2D(-1.0, 0)
if n == Direction.Down:
t._orient = Vec2D(0, -1.0)
if n == Direction.Right:
t._orient = Vec2D(1.0, 0)
def reset(self):
data = BRICKS_[randint(1, 7)]
self.color = data[0]
self.shapetype = [Vec2D(*x) for x in data[1]]
self.pos = Vec2D(COLUMNS // 2 - 1, 1)
if self.check(self.pos, self.shapetype):
self.board.state = "FALL"
self.shape1 = [self.pos + x for x in self.shapetype]
self.apply(None)
return True
else:
self.board.state = "FINIS"
self.shape1 = ()
return False
def __init__(self):
super(firstExample, self).__init__()
self.addBoundary(boundary.RectangularBoundary(300, 300))
self.append(Particle(Vec2D(0, 0), Vec2D(1, 0.5)))
self.append(Particle(Vec2D(-20, -30), Vec2D(-1.2, 0.7)))
self.append(Particle(Vec2D(40, 60), Vec2D(-1, -0.35)))
self.append(Particle(Vec2D(100, -50), Vec2D(-2, 0.61)))
def test_move_step(self):
"""
Test the AioBaseTurtle._move_step function
"""
t = AioBaseTurtle()
t._move_step(Vec2D(-100, 0), 20, Vec2D(10, 5))
self.assertAlmostEqual(t._position[0], 100)
self.assertAlmostEqual(t._position[1], 100)
t.screen._drawline.assert_called_once_with(
t.currentLineItem,
((-100.0, 0.0), (100.0, 100.0)), # called with mutable _position
"black",
1,
False)
self.mock_update.assert_called_once_with()
def main():
global sun
createPlanetShape()
## setup gravitational system
gs = GravSys()
sun = Star(1000000, Vec2D(50, 0), Vec2D(0, -3.5), gs, "circle")
sun.color("yellow")
sun.turtlesize(1.8)
sun.pu()
earth = Star(10000, Vec2D(150, 0), Vec2D(0, 350), gs, "planet")
earth.pencolor("green")
Screen().tracer(False)
gs.init()
gs.start()
return "Done!"
def acc(self, p):
a = Vec2D(0, 0)
for o in self:
if o != p: # apply law of gravity
r = o.position - p.position
a += (GRAVITY * o.mass / abs(r)**3) * r
return a
def acc(self):
a = Vec2D(0,0)
for planet in self.gravSys.planets:
if planet != self:
r = planet.pos()-self.pos()
a += (G*planet.m/abs(r)**3)*r
return a
def store(self, x, y):
clicktime = time.clock()
if clicktime - self.clicktime < 0.4:
self.flip()
self.clicktime = -1
else:
self.clicktime = clicktime
self.clickpos = Vec2D(x,y)
def drawBoundary(self):
if (self.ps.boundary):
b = self.ps.boundary
else:
return None
t = self.defaultTurtle
t.pu()
t.ht()
if isinstance(b, boundary.RectangularBoundary):
(w, h) = Vec2D(b.width, b.height) * 0.5
t.setpos(-w, -h)
t.pd()
t.setpos(w, -h)
t.setpos(w, h)
t.setpos(-w, h)
t.setpos(-w, -h)
t.pu() # x axis
t.setpos(-w, 0)
t.pd()
t.setpos(+w, 0)
t.pu() # y-axis
t.setpos(0, -h)
t.pd()
t.setpos(0, +h)
elif isinstance(b, boundary.CircularBoundary):
r = b.radius
t.setpos(Vec2D(0, r))
t.pd()
t.circle(r)
t.pu() # x axis
t.setpos(-r, 0)
t.pd()
t.setpos(+r, 0)
t.pu() # y-axis
t.setpos(0, -r)
t.pd()
t.setpos(0, +r)
def main():
global s, sun
s = Screen()
s.setup(800, 600)
s.screensize(750, 550)
createPlanetShape()
## setup gravitational system
s.setworldcoordinates(-4.e11, -3.e11, 4.e11, 3.e11)
gs = GravSys()
sun = Star(mS, Vec2D(0., 0.), Vec2D(0., 0.), gs, "circle")
sun.color("yellow")
sun.turtlesize(1.2)
sun.pu()
earth = Star(mE, Vec2D(rE, 0.), Vec2D(0., vE), gs, "planet")
earth.pencolor("green")
gs.init()
gs.start()
return "Done!"
def line(self, color, start, end, thickness):
if thickness != 1:
return pygame.draw.line(self.screen, color,
start + Vec2d(self.offset, 0),
end + Vec2d(self.offset, 0), thickness)
else:
return pygame.draw.aaline(self.screen, color,
start + Vec2d(self.offset, 0),
end + Vec2D(self.offset, 0))
def __init__(self, initialLocation=Vec2D(0, 0), vector=Vector(0, 0)):
if type(initialLocation) == type(tuple()):
self.location = Vector(initialLocation).toVec2D()
else:
self.location = initialLocation
global turtleInstance
if turtleInstance.position() != self.location:
turtleInstance.goto(self.location)
self.object = turtleInstance.clone()
def test_calc_move(self):
"""
Test the AioBaseTurtle._calc_move function
"""
t = AioBaseTurtle()
t.speed(speed=5)
steps, delta = t._calc_move(Vec2D(0, 100))
self.assertEqual(steps, 20)
self.assertAlmostEqual(delta[0], 0.0)
self.assertAlmostEqual(delta[1], 5.0)
def update(self, delta, left_player, right_player):
global width
self.position += self.velocity * delta
if (self.x < 100 and self.vx < 0) or (self.x > width - 100
and self.vx > 0):
for item in [left_player, right_player]:
if self.intersects(item):
item.success()
cx, cy = item.center
w, h = item.size
relative_y = (cy - self.y) / (h / 2)
speed = self.speed + (abs(relative_y) / 4)
angle = relative_y * 5 * (math.pi / 12)
if self.x > width / 2:
self.x = item.position.x - self.radius
self.velocity = Vec2D(speed * -math.cos(angle),
speed * -math.sin(angle))
else:
self.x = item.position.x + item.width + self.radius
self.velocity = Vec2D(speed * math.cos(angle),
speed * -math.sin(angle))
if self.x - self.radius < 0 and self.vx < 0:
left_player.fail()
self.reset()
elif self.x + self.radius > width and self.vx > 0:
right_player.fail()
self.reset()
if self.y - self.radius < 0 and self.vy < 0:
self.y = self.radius
self.vy *= -1
elif self.y + self.radius > height and self.vy > 0:
self.y = height - self.radius
self.vy *= -1
def __init__(self,
initialLocation=Vec2D(0, 0),
vector=Vector(0, 0),
t: int = 0):
super().__init__(initialLocation, vector)
self.draw()
self.changeDirection(vector)
# self.object.left(vector.angle())
if t != 0:
self.object.hideturtle()
self.t = t
def __init__(self,
initialLocation=Vec2D(0, 0),
direction=Direction.Vertical):
#code needs to be refined here
# print(initialLocation[0])
# if initialLocation[0] == 0.0:
# direction == Direction.Horizontal
if direction == Direction.Vertical:
self.size = self.border, UI.SCREEN_HEIGHT * self.b
else:
self.size = UI.SCREEN_WIDTH * self.a, self.border
super().__init__(initialLocation, self.size)
def __init__(self,
robot=None,
turn_speed=1.0,
move_speed=1.0,
time_offset=0.,
*args,
**kwargs):
"""
A turtle.Turtle for controlling a CamJamRobot, using distance inputs.
"""
if robot:
self.robot = robot
else:
import gpiozero
self.robot = gpiozero.CamJamKitRobot() if not robot else robot
self.turn_speed = turn_speed # In full revolutions (360 degrees) per second
self.move_speed = move_speed
self.time_offset = time_offset
self._heading_vec = Vec2D(1., 0.)
self._current_coords = Vec2D(0., 0.)
def forward(self, distance: float):
"""Move forward by a number of pixels."""
dx = distance * math.cos(math.radians(self.heading))
dy = distance * math.sin(math.radians(self.heading))
self.position += Vec2D(dx, dy)
p = self.origin + self.position
if self.pendown:
self.canvas.line_to(*p)
else:
self.canvas.move_to(*p)
def __init__(self):
super(earthMoonSun, self).__init__()
sun = Particle(Vec2D(0, 0), Vec2D(0.01, -2.5), 1000000)
self.append(sun)
earth = Particle(Vec2D(210, 0), Vec2D(-0.91, 195), 12500)
self.append(earth)
moon = Particle(Vec2D(220, 0), Vec2D(-5.83, 295), 1)
self.append(moon)
def main(argv):
if len(sys.argv) < 2:
print("Usage: {} puzzle.txt".format(argv[0]))
return (1)
position = Vec2D(2, 0)
with open(argv[1]) as f:
for line in f:
for move in line.strip():
new_position = position + moves[move]
if in_bounds(new_position):
position = new_position
print(str(vec2digit(position)), end='')
print()
return 0
def update_gameplay(self, event): # 游戏进行场景
try:
if event and event.keysym in kDirs and kDirs[
event.keysym] + self.snake_dir != Vec2D(
0, 0): # 按下方向键且与当前方向不相反时
self.root.after_cancel(self.next_update)
self.snake_dir = kDirs[event.keysym]
if not self.move():
raise # 懒
elif not event: # 自动更新时
if not self.move():
raise
else: # 忽略其他按键
return
except: # 死亡
self.canvas.delete('SnakeBodys')
self.canvas.coords(self.food[1], (0, 0, 0, 0))
self.scene = kSceneOver
self.next_update = self.root.after(kUpdateDelay,
self.update) # 延迟执行下一次更新
