def main():
## create compound yellow/blue turtleshape for planets
global s
s = Screen()
s.setup(1120,840)
s.reset()
s.tracer(0, 0)
t = Turtle()
t.ht()
t.pu()
t.fd(6)
t.lt(90)
t.begin_poly()
t.circle(6, 180)
t.end_poly()
m1 = t.get_poly()
t.begin_poly()
t.circle(6,180)
t.end_poly()
m2 = t.get_poly()
planetshape = Shape("compound")
planetshape.addcomponent(m1,"orange")
planetshape.addcomponent(m2,"blue")
s.register_shape("planet", planetshape)
#s.tracer(1,0)
s.update()
## setup gravitational system
gs = GravSys()
sun = Star(1000000, Vec(-250,0), Vec(0,-0.35), gs, "circle")
sun.color("yellow")
sun.pensize(1.8)
sun.pu()
earth = Star(5000, Vec(450,0), Vec(0,70), gs, "planet")
earth.pencolor("green")
earth.shapesize(0.8)
rm=12.0583
vm=(8.0*5000/rm)**.5
moon = Star(1, Vec(450+rm,0), Vec(0,70+vm), gs, "planet")
moon.pencolor("blue")
moon.shapesize(0.5)
gs.init()
gs.start()
return "Done!"
class Food(Turtle):
def __init__(self):
super().__init__()
self.screen = Screen()
self.screen.register_shape("apple.gif")
self.screen.addshape("apple.gif")
self.shape("apple.gif")
self.penup()
self.shapesize(stretch_len=0.5, stretch_wid=0.5)
self.color("red")
self.speed("fastest")
self.refresh()
def refresh(self):
self.goto(x=randint(-270, 270), y=randint(-270, 270))
def draw_border(self):
self.goto(x=-300, y=-300)
self.pendown()
self.pensize(20)
for i in range(4):
self.setheading(90 - 90 * i)
self.forward(600)
self.penup()
self.refresh()
def main():
# Setup screen
screen = Screen()
screen.setup(width=1.0, height=1.0) # for fullscreen
screen.bgcolor('black')
screen.title("Gravity Assist Example")
# Instantiate gravitational system
gravsys = GravSys()
# Instantiate Planet
image_moon = 'moon_27x27.gif'
screen.register_shape(image_moon)
moon = Body(MOON_MASS, (500, 0), Vec(-500, 0), gravsys, image_moon)
moon.pencolor('gray')
# Build command-service-module (csm) shape
csm = Shape('compound')
cm = ((0, 30), (0, -30), (30, 0))
csm.addcomponent(cm, 'red', 'red')
sm = ((-60, 30), (0, 30), (0, -30), (-60, -30))
csm.addcomponent(sm, 'red', 'black')
nozzle = ((-55, 0), (-90, 20), (-90, -20))
csm.addcomponent(nozzle, 'red', 'red')
screen.register_shape('csm', csm)
# Instantiate Apollo 8 CSM turtle
ship = Body(1, (Ro_X, Ro_Y), Vec(Vo_X, Vo_Y), gravsys, "csm")
ship.shapesize(0.2)
ship.color('red') # path color
ship.getscreen().tracer(1, 0)
ship.setheading(90)
gravsys.sim_loop()
def main():
## create compound yellow/blue turtleshape for planets
global s
s = Screen()
s.setup(1120, 840)
s.reset()
s.tracer(0, 0)
t = Turtle()
t.ht()
t.pu()
t.fd(6)
t.lt(90)
t.begin_poly()
t.circle(6, 180)
t.end_poly()
m1 = t.get_poly()
t.begin_poly()
t.circle(6, 180)
t.end_poly()
m2 = t.get_poly()
planetshape = Shape("compound")
planetshape.addcomponent(m1, "orange")
planetshape.addcomponent(m2, "blue")
s.register_shape("planet", planetshape)
s.update()
## setup gravitational system
gs = GravSys()
sun = Star(1000000, Vec(-250, 0), Vec(0, -0.35), gs, "circle")
sun.color("yellow")
sun.pensize(1.8)
sun.pu()
earth = Star(5000, Vec(450, 0), Vec(0, 70), gs, "planet")
earth.pencolor("green")
earth.shapesize(0.8)
rm = 12.0583
vm = (8.0 * 5000 / rm)**.5
moon = Star(1, Vec(450 + rm, 0), Vec(0, 70 + vm), gs, "planet")
moon.pencolor("blue")
moon.shapesize(0.5)
gs.init()
gs.start()
s.tracer(True)
return "Done!"
def getScreen(ariaPic, llamaPic):
win = Screen()
win.title("Pong - Aria VS Llama")
win.bgcolor("black")
win.setup(width=800, height=600)
win.tracer(0)
win.register_shape(ariaPic)
win.register_shape(llamaPic)
# bind keys with player moves
win.listen()
win.onkeypress(aria_up,'w')
win.onkeypress(aria_down, 'x')
win.onkeypress(llama_up,'9')
win.onkeypress(llama_down, '3')
return win
def main():
screen = Screen()
screen.setup(width=1.0, height=1.0) # for fullscreen
screen.bgcolor('black')
screen.title("Apollo 8 Free Return Simulation")
gravsys = GravSys()
image_earth = 'earth_100x100.gif'
screen.register_shape(image_earth)
earth = Body(1000000, (0, -25), Vec(0,-2.5), gravsys, image_earth)
earth.pencolor('white')
earth.getscreen().tracer(n=0, delay=0)
image_moon = 'moon_27x27.gif'
screen.register_shape(image_moon)
moon = Body(32000, (344, 42), Vec(-27, 147), gravsys, image_moon)
moon.pencolor('gray')
csm = Shape('compound')
cm = ((0, 30), (0, -30), (30, 0))
csm.addcomponent(cm, 'white', 'white')
sm = ((-60, 30), (0, 30), (0, -30), (-60, -30))
csm.addcomponent(sm, 'white', 'black')
nozzle = ((-55, 0), (-90, 20), (-90, -20))
csm.addcomponent(nozzle, 'white', 'white')
screen.register_shape('csm', csm)
ship = Body(1, (Ro_X, Ro_Y), Vec(Vo_X, Vo_Y), gravsys, 'csm')
ship.shapesize(0.2)
ship.color('white')
ship.getscreen().tracer(1,0)
ship.setheading(90)
gravsys.sim_loop()
input()
def createPlanetShape():
s = Screen()
s.tracer(0, 0)
t = Turtle()
t.ht()
t.pu()
t.fd(6)
t.lt(90)
t.begin_poly()
t.circle(6, 180)
t.end_poly()
m1 = t.get_poly()
t.begin_poly()
t.circle(6, 180)
t.end_poly()
m2 = t.get_poly()
planetshape = Shape("compound")
planetshape.addcomponent(m1, "orange")
planetshape.addcomponent(m2, "blue")
s.register_shape("planet", planetshape)
s.tracer(True, 0)
def createPlanetShape():
s = Screen()
s.tracer(0, 0)
t = Turtle()
t.ht()
t.pu()
t.fd(6)
t.lt(90)
t.begin_poly()
t.circle(6, 180)
t.end_poly()
m1 = t.get_poly()
t.begin_poly()
t.circle(6, 180)
t.end_poly()
m2 = t.get_poly()
planetshape = Shape("compound")
planetshape.addcomponent(m1, "orange")
planetshape.addcomponent(m2, "blue")
s.register_shape("planet", planetshape)
s.tracer(True, 0)
def main():
# Setup screen
screen = Screen()
screen.setup(width=1.0, height=1.0) # For fullscreen.
screen.bgcolor('black')
screen.title("Apollo 8 Free Return Simulation")
# Instantiate gravitational system
gravsys = GravSys()
# Instantiate Earth turtle
#image_earth = 'earth_100x100.gif'
#screen.register_shape(image_earth)
t = Turtle()
screen.register_shape('earth', drawCircle(6.371, 72, t))
earth = Body(1000000, (-200, 0), Vec(0, -2.5), gravsys, 'earth')
earth.pencolor('white')
earth.fillcolor('white')
earth.getscreen().tracer(0, 0) # So csm polys won't show while drawing.
# Instantiate moon turtle
#image_moon = 'moon_27x27.gif'
#screen.register_shape(image_moon)
#moon_circle = circle(1.737)
screen.register_shape('moon', drawCircle(1.737, 72, t))
moon = Body(32000, (156.7, 0), Vec(-27, 147), gravsys, 'moon')
moon.pencolor('gray')
moon.fillcolor('gray')
# Build command-service-module(csm)shape
csm = Shape('compound')
cm = ((0, 0.1), (0, -0.1), (0.1, 0))
csm.addcomponent(cm, 'Silver', 'red') # Silver and red are also good.
screen.register_shape('csm', csm)
# Instantiate Apollo 8 CSM turtle
ship = Body(1, (Ro_X, Ro_Y), Vec(Vo_X, Vo_Y), gravsys, 'csm')
ship.shapesize(0.1)
ship.color('white') # Path color. Silver and red are also good.
ship.getscreen().tracer(1, 0)
ship.setheading(90)
gravsys.sim_loop()
screen.bye() #close window automatically
def main():
# Setup screen
screen = Screen()
screen.setup(width=1.0, height=1.0) # For fullscreen.
screen.bgcolor('black')
screen.title("Apollo 8 Free Return Simulation")
# Instantiate gravitational system
gravsys = GravSys()
# Instantiate Earth turtle
image_earth = 'earth_100x100.gif'
screen.register_shape(image_earth)
earth = Body(1000000, (0, -25), Vec(0, -2.5), gravsys, image_earth)
earth.pencolor('white')
earth.getscreen().tracer(0, 0) # So csm polys won't show while drawing.
# Instantiate moon turtle
image_moon = 'moon_27x27.gif'
screen.register_shape(image_moon)
moon = Body(32000, (344, 42), Vec(-27, 147), gravsys, image_moon)
moon.pencolor('gray')
# Build command-service-module(csm)shape
csm = Shape('compound')
cm = ((0, 30), (0, -30), (30, 0))
csm.addcomponent(cm, 'white', 'white') # Silver and red are also good.
sm = ((-60, 30), (0, 30), (0, -30), (-60, -30))
csm.addcomponent(sm, 'white', 'black')
nozzle = ((-55, 0), (-90, 20), (-90, -20))
csm.addcomponent(nozzle, 'white', 'white')
screen.register_shape('csm', csm)
# Instantiate Apollo 8 CSM turtle
ship = Body(1, (Ro_X, Ro_Y), Vec(Vo_X, Vo_Y), gravsys, 'csm')
ship.shapesize(0.2)
ship.color('white') # Path color. Silver and red are also good.
ship.getscreen().tracer(1, 0)
ship.setheading(90)
gravsys.sim_loop()
# pong
from turtle import Turtle, Screen, onkey
screen = Screen()
screen.setup(width=500, height=400)
screen.register_shape("paddle", ((0, 0), (50, 0), (50, 2), (0, 2)))
screen.register_shape("ball", ((0, 0), (50, 0), (50, 2), (0, 2)))
screen.listen()
class Paddle(Turtle):
def __init__(self, side):
super().__init__()
self.shape('paddle')
self.side = side
self.x = 0
self.y = 0
def reset(self):
self.penup()
if self.side == 'L':
self.x = -200
self.setx(self.x)
else:
self.x = 200
self.setx(self.x)
self.y = 25
self.sety(self.y)
def up(self):
self.y += 20
self.sety(self.y)
class GameView(object):
"""This class handles the user facing part of the game. This draws the
game board and components."""
def __init__(
self,
controller: GameController,
board_size: int,
grid_size: int = 3
) -> None:
self.controller = controller
#### Setup the screen.
# Change it to a square 50% larger than the game board size.
self.screen = Screen()
screen_size = int(board_size * 1.5)
self.resize_screen(screen_size, screen_size)
#### Setup the game board.
# Initialize the turtle that will draw the game board.
self.board = GameView.new_turtle()
self.lineweight = board_size / 60
self.board.pensize(self.lineweight)
self.board.speed(0)
#self.board.dot(0)
self.board_size = board_size
self.grid_size = grid_size
self.grid_line_spacing = board_size / grid_size
#### Create our player markers.
self.players = []
marker_scale = board_size / 100 / grid_size
marker_lineweight = 8 * marker_scale
self.create_player_shapes()
self.players.append(GameView.new_turtle('x marker',
marker_scale,
marker_lineweight))
self.players.append(GameView.new_turtle('o marker',
marker_scale,
marker_lineweight))
#### Final initialization
self.draw_board()
self.screen.onclick(self.mouse_click)
self.screen.mainloop()
def create_player_shapes(self, color: str = 'black') -> None:
"""Creates custom turtle shapes for the x and o player markers.
This method sets up custom shapes that can be used with the
turtle.shape() method. Recall that you could make your turtle look
like an actual turtle (instead of the default arrow shape) by calling
turtle.shape('turtle'). After this method has been called, you can
change the sape of your turtle to an x or an o by calling
turtle.shape('x marker') or turtle.shape('o marker').
These shapes are initialized at a size appropriate for display on a
3x3 grid on a 300px game board.
"""
# Build the x out of a backslash and forward slash.
# These numbers are the vertices of the slashes.
backslash = ((-25,-25), (25,25))
forwardslash = ((-25,25), (25,-25))
shape = Shape('compound')
shape.addcomponent(backslash, '', color)
shape.addcomponent(forwardslash, '', color)
self.screen.register_shape('x marker', shape)
# Approximate the o with a 20-sided polygon.
# These numbers are the vertices of the polygon.
circle = (( 00.00,-25.00), ( 07.73,-23.78), ( 14.69,-20.23),
( 20.23,-14.69), ( 23.78,-07.73), ( 25.00, 00.00),
( 23.78, 07.73), ( 20.23, 14.69), ( 14.69, 20.23),
( 07.73, 23.78), ( 00.00, 25.00), (-07.73, 23.78),
(-14.69, 20.23), (-20.23, 14.69), (-23.78, 07.73),
(-25.00, 00.00), (-23.78,-07.73), (-20.23,-14.69),
(-14.69,-20.23), (-07.73,-23.78),)
shape = Shape('compound')
shape.addcomponent(circle, '', color)
self.screen.register_shape('o marker', shape)
def draw_line(self, x: float, y: float, heading: float, length: float) -> None:
"""Draws a line on the game board.
Args:
x, y: The coordinates where the line starts.
heading: The angle of the line.
length: The length of the line.
"""
self.board.setheading(heading)
self.board.penup()
self.board.goto(x, y)
self.board.pendown()
self.board.forward(length)
def draw_board(self) -> None:
"""Draws the game board centered on the point (0,0)."""
# Each horizontal line will have a common starting x coordinate.
# Each vertical line will have a common starting y coordinate.
# These coordinates are equal to each other.
anchor = self.board_size / 2
# The y-coordinates of horizontal lines and the x-coordinates of
# vertical lines begin equal to each other and increment equally
increments = list(
anchor - i * self.grid_line_spacing
for i in range(1, self.grid_size)
)
for i in increments:
self.draw_line(i, anchor, 270, self.board_size)
self.draw_line(anchor, i, 180, self.board_size)
def mark_play(self, player: int, space: List[int]) -> None:
"""Marks a play on the game board.
Args:
player: The player to mark, based on play order, starting at 1.
space: The space to be marked. The bottom-left space is (0,0).
"""
# Offset the space coordinates so that (0,0) becomes the center space
space = [s - self.grid_size // 2 for s in space]
# Calculate the pixel offset between spaces on the game board
space_offset = self.board_size / self.grid_size
# Find the screen coordinates of the center of the selected space on
# the game board.
center = [space_offset * s for s in space]
current_player = self.players[player - 1]
current_player.goto(*center)
current_player.stamp()
def mouse_click(self, x: float, y: float) -> None:
"""Handles mouse click actions."""
# Ignore all clicks outside of the game board area
extent = self.board_size / 2
if not (-extent < x < extent and -extent < y < extent):
return
# Find the space on the board in which the mose was clicked
# The bottom-left square is space (0,0).
space = [round(c / self.grid_line_spacing) + self.grid_size // 2
for c in [x, y]]
# Ask the controller to make a play in this space
player = self.controller.make_play(space)
# If the play was successful, the controller will return the player
# who made the play
if player:
# Mark the play on the board
self.mark_play(player, space)
def resize_screen(self, width: int, height: int) -> None:
"""Resizes the screen."""
self.screen.setup(width, height)
@staticmethod
def new_turtle(
shape: Optional[str] = None,
scale: float = 1.0,
lineweight: float = 1.0
) -> Turtle:
"""Creates a new turtle and hides it.
Args:
shape: A valid shapename. See TurtleScreen documentation.
scale: A factor to scale the size the turtle.
lineweight: The thickness of the lines composing the shape.
Yields:
TurtleGraphicsError: For invalid shape names.
"""
t = Turtle()
t.shape(shape)
t.shapesize(scale, scale, lineweight)
t.penup()
t.hideturtle()
return t
from turtle import Screen
from AlienFleet import Fleet
from SpaceShip import SpaceShip
from Barrier import Barrier
from Scoreboard import Scoreboard
from time import sleep
from bullet import Bullet
import random
from AlienBomb import AlienBombManager
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("Space Invasion!!")
screen.tracer(0)
screen.register_shape('ship', ((-10, 0), (0, 10), (10, 0)))
screen.register_shape('alien.gif')
def FireBullet():
global bullet
if bullet == None:
bullet = Bullet(position_x=player.xcor(), position_y=player.ycor())
def DeleteBullet():
global bullet
bullet.goto(3000, 3000)
bullet.clear()
del bullet
bullet = None
t = Turtle("circle", visible=True)
t2 = Turtle("square", visible=False)
t3 = Turtle("square", visible=False)
t4 = Turtle("square", visible=True)
trat = 0
t4.color("blue")
print(t3.get_shapepoly())
t3.shapesize(10, .1)
print(t3.get_shapepoly())
t4.shapesize(10, .1)
t4.penup()
t2.penup()
v = 0
t3.color("blue")
s.tracer(False)
s.listen()
s.onkeypress(quit, "Escape")
t.penup()
t3.penup()
s.register_shape("hand", ((0, -10), (0, 10), (20, 10), (20, -10)))
t4.shape("hand")
t3.shape("hand")
create()
write()
t.onclick(erase)
t.ondrag(drag)
t.onrelease(release)
s.mainloop()
from player import Player
from obstacle import Obstacle
from laser import Laser
POSITIONX = 220
POITIONY = 360
move_speed = 0.1
laser_move_speed = 2
life = 3
obstacles = []
lasers = []
window = Screen()
window.register_shape("icons/invader_1_small.gif")
window.register_shape("icons/invader_2_small.gif")
window.register_shape("icons/invader_3_small.gif")
window.register_shape("icons/spaceship_small.gif")
screen = Screen()
screen.bgcolor("black")
screen.setup(height=800, width=600)
screen.title("breakout")
screen.tracer(0)
for position in range(10):
obstacle = Obstacle((POSITIONX, POITIONY), "icons/invader_3_small.gif")
POSITIONX -= 50
obstacles.append(obstacle)
snake[0].setheading(270)
def move_left():
if snake[0].heading() == 90 or snake[0].heading() == 270:
snake[0].setheading(180)
def move_right():
if snake[0].heading() == 90 or snake[0].heading() == 270:
snake[0].setheading(0)
leaf = Turtle()
leaf_shape = ((0, 0), (14, 2), (18, 6), (20, 20), (6, 18), (2, 14))
w.register_shape('leaf', leaf_shape)
leaf.shape('leaf')
leaf.color('green')
leaf.penup()
leaf.hideturtle()
leaf.speed(0)
game_started = False
text_turtle = Turtle()
text_turtle.write('Нажмите пробел, чтобы начать игру',
align='center',
font=('Arial', 16, 'bold'))
text_turtle.hideturtle()
score_turtle = Turtle()
from turtle import Screen
from background import create_world
from walker import Walker
from cars import Car
from signs import Level, GameOver
import random
import time
screen = Screen()
screen.setup(height=480, width=800)
screen.title("Cross the Road")
screen.register_shape("walker_graphic.gif")
screen.register_shape("cars/truck.gif")
screen.register_shape("cars/right_truck.gif")
screen.register_shape("walker_graph/dead1.gif")
screen.register_shape("walker_graph/dead2.gif")
screen.tracer(0)
create_world()
john = Walker()
level = Level(190, - 350, "white")
screen.update()
game_over = False
TRAFFIC = []
LEFT = 180
RIGHT = 0
LANE_RIGHT = (-190, -140, -90, -40)
}, {
'shape': 'platform',
'color': 'blue',
'physics': {
'weight': 100,
'speed': (0, 0),
'forces': [fly, bounce]
},
'init_params': {
'position': (400, -100)
}
}
]
for shape in shapes:
screen.register_shape(shape['name'], shape['poly'])
screen.onkey(jump(player, (0, 10)), 'Up')
screen.onkey(jump(player, (-10, 5)), 'Left')
screen.onkey(jump(player, (10, 5)), 'Right')
init_objects(objects)
screen.listen()
while True:
screen.tracer(n=10000)
for obj in objects:
processing(obj, objects)
# for obj in objects:
class Frame:
def __init__(self, width=800, height=600):
self.width = width
self.height = height
self.screen = Screen()
self.screen.setup(width=width + 100,
height=height + 100,
startx=0,
starty=0)
self.screen.setworldcoordinates(-50, -50, width + 50, height + 50)
self.quit = False
self.draw_frame()
def close(self):
self.screen.bye()
def clear(self):
self.draw_frame()
def draw_frame(self):
self.screen.clear()
width = self.width
height = self.height
boundary = Turtle()
boundary.hideturtle()
boundary.speed('fastest')
boundary.penup()
boundary.goto(0 + 2, 0 - 15)
boundary.write('0')
boundary.goto(0 - 8, 0)
boundary.write('0')
boundary.goto(0, 0)
boundary.pendown()
boundary.goto(width, 0)
boundary.penup()
boundary.goto(width - 10, 0 - 15)
boundary.write(str(int(width)))
boundary.goto(width, 0)
boundary.pendown()
boundary.goto(width, height)
boundary.goto(0, height)
boundary.penup()
boundary.goto(0 - 25, height - 10)
boundary.write(str(int(height)))
boundary.goto(0, height)
boundary.pendown()
boundary.goto(0, 0)
boundary.penup()
self.screen.register_shape("button",
((0, 0), (0, 85), (25, 85), (25, 0)))
t = Turtle(shape="button")
t.hideturtle()
t.penup()
t.fillcolor('pink')
t.goto(width - 95, -20)
t.showturtle()
boundary.goto(width - 62, -40)
boundary.write("Quit", font=("Arial", 12, "normal"))
self.screen.onclick(self.check_quit)
def check_quit(self, x, y):
self.quit = 706 < x < 792 and -47 < y < -20
class Game():
"""Make the game loop into a class.
Responsible for drawing and updating all our objects"""
def __init__(self):
# Set up the screen
self.screen = Screen()
self.screen.bgcolor("black")
self.screen.setup(width=650, height=700)
self.screen.title("Space Invaders")
self.screen.bgpic("assets\\sprites\\space_invaders_background.gif")
# Register the shapes
self.screen.register_shape("assets\\sprites\\invader.gif")
self.screen.register_shape("assets\\sprites\\player.gif")
# initial objects
self.player = Player()
self.bullet = Bullet(self.player)
self.score = Score()
self.border = Border()
self.game_over = False
# Create invaders
self.number_of_enemies = 5
self.enemies = []
for i in range(self.number_of_enemies):
self.enemies.append(Invader())
# Create keyboard bindings
self.screen.listen()
self.screen.onkey(self.player.move_left, "Left")
self.screen.onkey(self.player.move_right, "Right")
self.screen.onkey(self.bullet.fire_bullet, "space")
def play_sound(self, filename):
winsound.PlaySound("assets\\sounds\\{}".format(filename),
winsound.SND_ASYNC)
def run(self):
"""Make the game loop a function."""
while True:
# When game_over is set, stop updating objects
if not self.game_over:
# for each enemy
for invader in self.enemies:
# Move the enemy left/right
invader.move_left_right()
# get the enemy back and down
if (invader.xcor() < -280 or invader.xcor() > 280):
# Move all enemies down
for enemy in self.enemies:
enemy.move_down()
# Change enemy direction
enemy.invader_speed *= -1
if invader.ycor() < -250:
self.game_over = True
print("Game Over")
if is_collision(self.bullet, invader) == True:
self.play_sound("explosion.wav")
self.bullet.reset_positon()
self.score.change_score(10)
invader.reset_positon()
if is_collision(self.player, invader) == True:
self.player.hideturtle()
invader.hideturtle()
self.game_over = True
print("Game Over")
# Move the bullet
if self.bullet.state == "fire":
self.bullet.move_up()
# Check to see if bullet has gone to the top
if self.bullet.ycor() > 275:
self.bullet.reset_positon()
# Display the screen.
self.screen.update()
else:
break
# pause game
input("Press enter to finish")
class Window:
def __init__(self, size):
# Some basic stuff.
self.window = Screen()
self.window.title("Pong Game for AGH")
self.window.bgcolor("white")
self.window.setup(
width=size[0], height=size[1]
) # Set size from file. (It is converted to tuple before).
self.window.tracer(0) # Allow draw things immediately.
self.vertical_margin = 60 # Margin for area.
self.horizontal_margin = 20
# Setting our game area - place where ball is moving and paddles.
self.top = self.window.window_height() / 2 - self.vertical_margin
self.bottom = -self.window.window_height() / 2 + self.vertical_margin
self.left = -self.window.window_width() / 2 + self.horizontal_margin
self.right = self.window.window_width() / 2 - self.horizontal_margin
# Making (drawing) area.
self.area = Turtle()
self.area.hideturtle() # Hide turtle on the screen.
self.area.penup() # No drawing when moving.
self.area.goto(self.right, self.top)
self.area.pendown() # Pull the pen down - start drawing.
self.area.goto(self.left, self.top)
self.area.goto(self.left, self.bottom)
self.area.goto(self.right, self.bottom)
self.area.goto(self.right, self.top)
# Initialization of score writing and pause text.
self.score_turtle = Turtle()
self.score_turtle.penup()
self.score_turtle.hideturtle()
self.pause_text = Turtle()
self.pause_text.hideturtle()
def update(self): # Update method for main.
self.window.update()
def add_shape(self, shape, str): # Add shape to window.
self.window.register_shape(str, shape)
def get_area(self): # Return area size. (Needed for ball and paddles)
area = []
area.append(self.top)
area.append(self.bottom)
area.append(self.left)
area.append(self.right)
return area
def write_scores(self, score):
self.score_turtle.clear()
# Go to above and below paddles and write score.
self.score_turtle.goto(
0,
self.window.window_height() / 2 - self.vertical_margin)
self.score_turtle.write(score[0],
align="center",
font=("Arial", 32, "bold"))
self.score_turtle.goto(
0, -self.window.window_height() / 2 + self.vertical_margin / 6)
self.score_turtle.write(score[1],
align="center",
font=("Arial", 32, "bold"))
def write_pause(self, pause):
if pause == True:
self.pause_text.penup() # No drawing when moving.
self.pause_text.goto(0, 0) # Go to middle of the screen and write.
self.pause_text.write("PAUSE. CLICK P AGAIN TO RESUME",
align="center",
font=("Arial", 18, "bold"))
if pause == False:
self.pause_text.undo() # Undo previously written text.
area.goto(play_right, play_top)
# PADDLES
L = Turtle()
R = Turtle()
L.penup()
R.penup()
# Paddles shape
paddle_w_half = 10 / 2 # 10 units wide
paddle_h_half = 40 / 2 # 40 units high
paddle_shape = Shape("compound")
paddle_points = ((-paddle_h_half, -paddle_w_half), (-paddle_h_half,
paddle_w_half),
(paddle_h_half, paddle_w_half), (paddle_h_half,
-paddle_w_half))
paddle_shape.addcomponent(paddle_points, "black")
screen.register_shape("paddle", paddle_shape)
L.shape("paddle")
R.shape("paddle")
# Move paddles into position
L.setx(play_left + 10)
R.setx(play_right - 10)
paddle_L_move_direction = 0 # L paddle movement direction in next frame
paddle_R_move_direction = 0 # R paddle movement direction in next frame
paddle_move_vert = 4 # Vertical movement distance per frame
def paddle_is_allowed_to_move_here(new_y_pos):
if (play_bottom > new_y_pos -
paddle_h_half): # bottom of paddle below bottom of field
return False
if (new_y_pos + paddle_h_half >
import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor('black')
screen.bgpic('cross_road_bg.gif')
screen.tracer(0)
screen.register_shape('turtle.gif')
screen.register_shape('car_green.gif')
screen.register_shape('car_blue.gif')
screen.register_shape('car_pink.gif')
screen.register_shape('car_purple.gif')
screen.register_shape('car_orange.gif')
screen.register_shape('car_yellow.gif')
car_manager = CarManager()
scoreboard = Scoreboard()
player = Player()
screen.listen()
screen.onkey(player.go_up, "Up")
game_is_on = True
while game_is_on:
time.sleep(0.1)
screen.update()
def getDY(self):
return self.dy
def intersect(object1, object2):
dist = math.sqrt((object1.xcor() - object2.xcor()) ** 2 +
(object1.ycor() - object2.ycor()) ** 2)
radius1 = object1.getRadius()
radius2 = object2.getRadius()
return dist <= radius1 + radius2
screen.register_shape("rock3", ((-20, -16), (-21, 0), (-20, 18), (0, 27),
(17, 15), (25, 0), (16, -15), (0, -21)))
screen.register_shape("rock2", ((-15, -10), (-16, 0), (-13, 12), (0, 19),
(12, 10), (20, 0), (12, -10), (0, -13)))
screen.register_shape("rock1", ((-10, -5), (-12, 0), (-8, 8), (0, 13), (8, 6),
(14, 0), (12, 0), (8, -6), (0, -7)))
screen.register_shape("ship", ((-10, -10), (0, -5), (10, -10), (0, 10)))
screen.register_shape("bullet", ((-2, -4), (-2, 4), (2, 4), (2, -4)))
ship = SpaceShip(screen, 0, 0, (screenMaxX - screenMinX) / 2 + screenMinX,
(screenMaxY - screenMinY) / 2 + screenMinY)
asteroids = []
for k in range(5):
dx = random.random() * 6 - 3
dy = random.random() * 6 - 3
t.fd(20) t.left(120) t.fd(20) t.right(60) t.fd(20) t.right(120) t.fd(20) t.right(60) t.fd(20) t.right(120) t.fd(20) t.end_poly() p = t.get_poly() t.reset() shape = 'myShape' screen.register_shape(shape, p) t.penup() t.sety(len(turtles)*gap) t.shape(shape) turtles.append(t) import os file_path = os.path.realpath(__file__) dir_path = os.path.dirname(file_path) shape = os.path.join(dir_path, 'b.gif') screen.register_shape(shape) t = Turtle() t.penup() t.sety(len(turtles)*gap) t.shape(shape) turtles.append(t)
ts.getcanvas().postscript(file="letter.eps")
imgNew = Image.open("letter.eps")
#imgNew.convert("RGBA")
imgNew.save('letter1.png', quality=90, lossless=True)
messagebox.showinfo("Message Box",
"Drawing saved as image file successfully.")
else:
print("Some error occured")
def dragging(x, y):
yertle.ondrag(None)
#yertle.setheading(yertle.towards(x, y))
yertle.goto(x, y)
yertle.ondrag(dragging)
screen = Screen()
#screen.bgcolor("orange")
yertle = Turtle('classic')
screen.register_shape("pen1.gif")
yertle.shape("pen1.gif")
yertle.speed('fast')
screen.title("Draw characters here")
yertle.pensize(5)
#yertle.pencolor("white")
yertle.turtlesize(stretch_wid=2, stretch_len=2, outline=5)
yertle.onclick(dragging)
yertle.onrelease(dialogue, btn=1, add=None)
screen.mainloop()
import pandas
from turtle import Turtle, Screen
#TODO: Create Turtle Screen that has the image as a bg and
screen = Screen()
state_image = Turtle()
image = "blank_states_img.gif"
screen.register_shape("blank_states_img.gif")
state_image.shape(image)
data = pandas.read_csv("50_states.csv")
all_states = data.state.to_list()
guessed_states = []
while len(guessed_states) < 50:
answer_state = screen.textinput(title=f"States Guessed: {len(guessed_states)}/50",
prompt="What's another state's name?").title()
if answer_state in all_states:
guessed_states.append(answer_state)
t = Turtle()
t.hideturtle()
t.penup()
state_data = data[data.state == answer_state]
t.goto(int(state_data.x), int(state_data.y))
t.write(answer_state)
screen.exitonclick()
# Define Globals
delay = 0.1
score = 0
hscore = 0
# Screen setup
wn = Screen()
wn.title('Snake')
wn.bgcolor('green')
wn.bgpic('background.gif')
wn.setup(600, 600)
wn.tracer(0)
# Register Images
wn.register_shape('apple.gif')
wn.register_shape('head.gif')
wn.register_shape('headd.gif')
wn.register_shape('headl.gif')
wn.register_shape('headr.gif')
wn.register_shape('segmentu.gif')
wn.register_shape('segmentd.gif')
wn.register_shape('segmentl.gif')
wn.register_shape('segmentr.gif')
# Player
p = Turtle()
p.shape('head.gif')
p.color('black')
p.speed(10)
p.penup()
import random
from turtle import Turtle, Screen
screen = Screen()
screen.bgcolor('pink')
caterpillar = Turtle('square', visible=False)
caterpillar.color('red')
caterpillar.speed('fastest')
caterpillar.penup()
leaf_shape = ((0, 0), (14, 2), (18, 6), (20, 20), (6, 18), (2, 14))
screen.register_shape('leaf', leaf_shape)
leaf = Turtle('leaf', visible=False)
leaf.color('green')
leaf.speed('fastest')
leaf.penup()
game_started = False
text_turtle = Turtle(visible=False)
text_turtle.write('Press SPACE to start',
align='center',
font=('Arial', 150, 'bold'))
score_turtle = Turtle(visible=False)
score_turtle.speed('fastest')
score_turtle.penup()
x = (screen.window_width() / 2) - 50
y = (screen.window_height() / 2) - 50
score_turtle.setpos(x, y)
class MaquinaVirtual:
def __init__(self):
self.programa = None
self.memoria = Memoria()
self.estrella = None
self.screen = None
self.turtle_activa = False
self.pila_contextos = []
def agarra_datos(self, program):
'''
Recibe archivos con cuádruplos y el directorio de funciones y constantes
:param program: Nombre del programa compilado
'''
compilado = f"pruebas/{program}_comp.ta"
arch_compilado = open(compilado, 'r')
todito = json.load(arch_compilado)
self.pila_contextos.append('star')
self.programa = program
self.haz_constantes(todito['tConstantes'])
self.haz_quads(todito['Quads'], todito['FunDir'])
# dnb
def haz_quads(self, quads, fun_dir, sig=0):
'''
Procesar cada cuadruplo de la lista de Quads recibida hasta que encuentre END
:param quads: Lista con todos los quads
:param fun_dir: Directorio de funciones
:param sig: Apuntador al siguiente cuádruplo
'''
# parametros que estamos mandando
parametros = []
retornado = None
while True:
operador = quads[sig][0]
op_izq = quads[sig][1]
op_der = quads[sig][2]
res = quads[sig][3]
# checamos que si traen ( ) y vamos por su valor
if isinstance(op_izq, str) and op_izq[0] == '(':
op_izq = self.dame_contenido(op_izq)
if isinstance(op_der, str) and op_der[0] == '(':
op_der = self.dame_contenido(op_der)
if isinstance(res, str) and res[0] == '(':
res = self.dame_contenido(res)
if operador == '=':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
tipo_res = self.dame_tipo(res)
mem_r[res] = tipo_res(mem1[op_izq])
sig += 1
elif operador == '+':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
# suma de un string con algo más
if (isinstance(mem1[op_izq], str)
and not isinstance(mem2[op_der], str)) or (
isinstance(mem2[op_der], str)
and not isinstance(mem1[op_izq], str)):
mem_r[res] = str(mem1[op_izq]) + str(mem2[op_der])
else:
mem_r[res] = mem1[op_izq] + mem2[op_der]
sig += 1
elif operador == '-':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] - mem2[op_der]
sig += 1
elif operador == '*':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] * mem2[op_der]
sig += 1
elif operador == '/':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
tipo_res = self.dame_tipo(res)
if mem2[op_der] == 0:
raise TypeError(f"Error: No se puede dividir entre 0")
mem_r[res] = tipo_res(mem1[op_izq] / mem2[op_der])
sig += 1
elif operador == '>':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] > mem2[op_der]
sig += 1
elif operador == '<':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] < mem2[op_der]
sig += 1
elif operador == '>=':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] >= mem2[op_der]
sig += 1
elif operador == '<=':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] <= mem2[op_der]
sig += 1
elif operador == '!=':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] != mem2[op_der]
sig += 1
elif operador == '==':
mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
mem_r[res] = mem1[op_izq] == mem2[op_der]
sig += 1
elif operador == 'print':
mem = self.dame_mem(res)
# no borrar este print
print(mem[res])
sig += 1
elif operador == 'read':
mem = self.dame_mem(res)
mem[res] = input()
sig += 1
elif operador == 'GotoF':
# memoria de valor booleano
mem_b = self.dame_mem(op_izq)
if not mem_b[op_izq]:
sig = int(res) - 1
else:
sig += 1
elif operador == 'GotoV':
mem_b = self.dame_mem(op_izq)
if mem_b[op_izq]:
sig = int(res) - 1
else:
sig += 1
elif operador == 'Goto_main' or operador == 'Goto':
sig = int(res) - 1
# activamos memoria star
elif operador == 'END':
self.memoria.cuello()
self.pila_contextos.pop()
# tenemos que borrar algo más ?
break
#################################### GRAPH STATEMENTS ####################################
# 0 exp
elif operador == 'hand_down':
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.pd()
sig += 1
elif operador == 'hand_up':
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.pu()
sig += 1
elif operador == 'hide_star':
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.hideturtle()
sig += 1
elif operador == 'show_star':
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.showturtle()
sig += 1
elif operador == 'exitonclick':
if not self.turtle_activa:
self.activa_tortuga()
self.screen.exitonclick()
sig += 1
elif operador == 'clear':
if not self.turtle_activa:
self.activa_tortuga()
self.screen.clear()
sig += 1
elif operador == 'begin_fill':
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.begin_fill()
sig += 1
elif operador == 'end_fill':
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.end_fill()
sig += 1
# 1 exp
elif operador == 'circle':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.circle(mem[op_izq])
sig += 1
elif operador == 'left':
mem = self.dame_mem(op_izq)
angle = float(mem[op_izq])
if not self.turtle_activa:
self.activa_tortuga()
if angle > 360:
raise TypeError(f"Valor no debe exceder 360 grados")
self.estrella.lt(angle)
sig += 1
elif operador == 'right':
mem = self.dame_mem(op_izq)
angle = float(mem[op_izq])
if not self.turtle_activa:
self.activa_tortuga()
if angle > 360:
raise TypeError(f"Valor no debe exceder 360 grados")
self.estrella.rt(angle)
sig += 1
elif operador == 'back':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.bk(mem[op_izq])
sig += 1
elif operador == 'go':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.fd(mem[op_izq])
sig += 1
elif operador == 'square':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
# grafica cuadrado
self.estrella.forward(mem[op_izq])
self.estrella.left(90)
self.estrella.forward(mem[op_izq])
self.estrella.left(90)
self.estrella.forward(mem[op_izq])
self.estrella.left(90)
self.estrella.forward(mem[op_izq])
self.estrella.left(90)
sig += 1
elif operador == 'rectangle':
mem1 = self.dame_mem(op_izq) # base
mem2 = self.dame_mem(op_der) # altura
base = mem1[op_izq]
altura = mem2[op_der]
if not self.turtle_activa:
self.activa_tortuga()
# grafica rectangulo
self.estrella.fd(base)
self.estrella.lt(90)
self.estrella.fd(altura)
self.estrella.lt(90)
self.estrella.fd(base)
self.estrella.lt(90)
self.estrella.fd(altura)
self.estrella.lt(90)
sig += 1
elif operador == 'triangle':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
# dibuja triangulo equilatero de base ingresada
self.estrella.fd(mem[op_izq])
self.estrella.lt(120)
self.estrella.fd(mem[op_izq])
self.estrella.lt(120)
self.estrella.fd(mem[op_izq])
sig += 1
elif operador == 'speed':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
speed = mem[op_izq]
if self.dame_tipo(op_izq) is not str:
if not 1 <= speed <= 10:
raise TypeError(
f"Valor de la velocidad debe estar entre 0 y 10.")
elif speed not in [
'fastest', 'fast', 'normal', 'slow', 'slowest'
]:
raise TypeError(f"Velocidad {speed} no válida.")
self.estrella.speed(mem[op_izq])
sig += 1
elif operador == 'color_star':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
color = mem[op_izq]
self.estrella.color(color)
sig += 1
elif operador == 'size_star':
mem = self.dame_mem(op_izq)
if not self.turtle_activa:
self.activa_tortuga()
size = mem[op_izq]
self.estrella.pensize(size)
sig += 1
# 2 exp
elif operador == 'position':
mem1 = self.dame_mem(op_izq)
mem2 = self.dame_mem(op_der)
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.setpos(mem1[op_izq], mem2[op_der])
sig += 1
elif operador == 'arc':
# arc(angulo,radio)
mem1 = self.dame_mem(op_izq)
mem2 = self.dame_mem(op_der)
if not self.turtle_activa:
self.activa_tortuga()
self.estrella.circle(mem2[op_der], mem1[op_izq])
sig += 1
##########################################################################################
elif operador == 'VER':
mem1 = self.dame_mem(op_izq)
mem2 = self.dame_mem(op_der)
if not (0 <= mem1[op_izq] < mem2[op_der]):
raise TypeError(f"OUT OF BOUNDS")
sig += 1
############ FUNCIONES ############
elif operador == 'ERA':
fun = fun_dir[res]
if self.memoria.activa is not None:
superior = self.memoria.activa
else:
superior = self.memoria
self.memoria.record_activacion(superior, fun['vars'])
sig += 1
elif operador == 'GOSUB':
self.memoria.activa = self.memoria.mem_ejec[list(
self.memoria.mem_ejec.keys())[-1]]
self.pila_contextos.append(res)
self.memoria.activa.matcheo(parametros)
parametros.clear()
val = self.haz_quads(quads, fun_dir, int(res) - 1)
# return
if val is not None:
mem = self.dame_mem(op_izq)
mem[op_izq] = val
sig += 1
elif operador == 'RETURN':
mem = self.dame_mem(res)
retornado = mem[res]
sig += 1
elif operador == 'param':
mem = self.dame_mem(res)
parametros.append(mem[res])
sig += 1
elif operador == 'ENDPROC':
self.memoria.cuello()
self.pila_contextos.pop()
if retornado is not None:
return retornado
else:
break
def haz_constantes(self, t):
'''
Genera tabla de constantes y las carga a memoria
:param t: Tabla de constantes
'''
for const in t:
dir = const[0]
val = const[1]
self.memoria.mem_constantes[dir] = val
'''
GLOBAL
i [1000 - 5999]
f [6000 - 10999]
s [11000 - 15999]
b [16000 - 20999]
LOCAL
i [21000 - 25999]
f [26000 - 30999]
s [31000 - 35999]
b [36000 - 40999]
CONSTANTES
c [41000 - 51999]
'''
def dame_memorias(self, op_i, op_d, res):
'''
Regresa las direcciones de memoria a las que pertenecen los elementos de un cuádruplo a excepción del operador
:param op_i: Operador izquierdo del quad
:param op_d: Operador derecho del quad
:param res: Resultado del quad
:return: Memoria correspondiente
'''
return self.dame_mem(op_i), self.dame_mem(op_d), self.dame_mem(res)
def dame_mem(self, dir):
'''
Regresa la dirección a la que pertenece la variable global, local o de constantes
:param dir: Dirección de variable
'''
if dir is None:
return None
elif 1000 <= dir < 21000:
return self.memoria.mem_global
elif 21000 <= dir < 41000:
return self.memoria.activa.mem_local if self.memoria.activa is not None else self.memoria.mem_local
else:
return self.memoria.mem_constantes
def dame_tipo(self, dir):
'''
Regresa el tipo de variable
:param dir: Dirección de variable
'''
if 1000 <= dir < 6000 or 21000 <= dir < 26000:
return int
elif 6000 <= dir < 11000 or 26000 <= dir < 31000:
return float
elif 11000 <= dir < 16000 or 31000 <= dir < 36000:
return str
elif dir >= 41000:
return type(self.memoria.mem_constantes[dir])
else:
return bool
def activa_tortuga(self):
self.turtle_activa = True
s = Turtle()
self.screen = Screen()
self.dibuja_estrella(s)
self.screen.title(self.programa)
self.screen.clear()
self.estrella = Turtle(shape="estrella")
def dibuja_estrella(self, lapiz):
'''
Define una figura de estrella como el lapiz que dibujará
'''
fig = Shape("compound")
lapiz.setx(0)
lapiz.sety(4)
lapiz.begin_poly()
lapiz.goto(1, 1)
lapiz.goto(3.5, 1)
lapiz.goto(1.5, -0.5)
lapiz.goto(2.5, -3)
lapiz.goto(0, 1.5)
lapiz.goto(-2.5, -3)
lapiz.goto(-1.5, -0.5)
lapiz.goto(-3.5, 1)
lapiz.goto(-1, 1)
lapiz.end_poly()
fig.addcomponent(lapiz.get_poly(), "purple", "purple")
self.screen.register_shape("estrella", fig)
lapiz.reset()
def dame_contenido(self, dir):
dir_aux = int(dir[1:-1])
dir_mem = self.dame_mem(dir_aux)
return dir_mem[dir_aux]
from turtle import Screen, Turtle
screen = Screen()
screen.setup(950, 200)
screen.register_shape('segment', ((-14.5, 0), (-12, 2.5), (12, 2.5), (14.5, 0), (12, -2.5), (-12, -2.5))) # <=>
SCALE = 1.75 # arbitrarily scale digits larger or smaller
CURSOR_SIZE = 25 # maximum dimension of our custom turtle cursor
SPACING = CURSOR_SIZE * 1.25 * SCALE # space from start of one digit to the next
DIGITS = { # which segments to turn on encoded as bits
'0': 0b1111110,
'1': 0b0110000,
'2': 0b1101101,
'3': 0b1111001,
'4': 0b0110011,
'5': 0b1011011,
'6': 0b1011111,
'7': 0b1110000,
'8': 0b1111111,
'9': 0b1111011,
'A': 0b1110111,
'B': 0b0011111,
'C': 0b1001110,
'D': 0b0111101,
'E': 0b1001111,
'F': 0b1000111,
}
import time
from turtle import Screen
from player import Player
from car_manager import Cars
from scoreboard import Scoreboard
cars = ["car1.gif", "car2.gif", "car4.gif", "car5.gif", "car6.gif", "car7.gif", "car8.gif"]
screen = Screen()
screen.title("Turtle Crossing Game")
screen.setup(width=600, height=600)
screen.bgpic("highway1.gif")
for car_index in cars:
screen.register_shape(car_index)
screen.tracer(0)
player = Player()
car_manager = Cars(cars)
scoreboard = Scoreboard()
screen.listen()
screen.onkey(fun=player.move_up, key="Up")
screen.onkey(fun=player.move_down, key="Down")
game_on = True
while game_on:
screen.update()
time.sleep(0.1)
car_manager.create_car()
car_manager.move()
