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 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()