def create_new_screen(width, height, bgcolor): scr = Screen() scr.clear() scr.title('Turtle Race...!!') scr.setup(width=width, height=height) scr.colormode(255) scr.bgcolor(bgcolor) return scr
def play(): screen = Screen() screen.setup(width=600, height=600) screen.bgcolor("black") screen.title("Snake Snake Snake") screen.tracer(0) snake = Snake() food = Food() scoreboard = Scoreboard() screen.listen() screen.onkey(snake.up, "Up") screen.onkey(snake.down, "Down") screen.onkey(snake.left, "Left") screen.onkey(snake.right, "Right") game_is_on = True while game_is_on: screen.update() time.sleep(.1) snake.move() # Detect Collision with food if snake.head.distance(food) < 15: scoreboard.increase_score() snake.extend() food.refresh() print("nom nom nom") # Detect Collision with wall if snake.head.xcor() > 280 or snake.head.xcor( ) < -280 or snake.head.ycor() > 280 or snake.head.ycor() < -280: scoreboard.reset_score() snake.reset_snake() answer = screen.textinput("Replay?", "Y/N").lower() if answer == "y": screen.clear() play() else: screen.bye() # Detect Collision with Tail for segment in snake.segments: if segment == snake.head: pass elif snake.head.distance(segment) < 10: scoreboard.reset_score() snake.reset_snake() answer = screen.textinput("Replay?", "Y/N").lower() if answer == "y": screen.clear() play() else: screen.bye() screen.exitonclick()
def setup(): wn = Screen() wn.setup(300, 300) wn.clear() turtle.delay(0) travis = Turtle() travis.hideturtle() travis.speed(0) return travis, wn
class GameMaster: def __init__(self): self.screen = Screen() self.screen.setup(width=600, height=600) self.set_up_screen() self.scoreboard = Scoreboard() self.cars = CarManager() self.player = Player() self.set_up_control(self.player) self.game_loop(self.player, self.cars, self.scoreboard) def set_up_screen(self): self.screen.clear() self.screen.tracer(0) self.screen.bgcolor("black") self.screen.listen() def set_up_control(self, player): self.screen.onkeypress(player.move_up, "Up") self.screen.onkey(self.new_game, "n") def new_game(self): self.__init__() self.set_up_screen() self.set_up_control(self.player) self.game_loop(self.player, self.cars, self.scoreboard) def game_loop(self, player, cars, scoreboard): game_is_on = True while game_is_on: time.sleep(0.1) self.screen.update() cars.move_cars() # Detect finish line if player.detect_finish_line(): print("Finish achieved") scoreboard.level_up() cars.increase_speed() cars.increase_probability_threshold() # Detect collision with car for car in cars.cars: if abs(player.ycor() - car.ycor()) < 20 and player.distance(car) < 36: print(f"Collision with distance {player.distance(car)}") print( f"Car x: {car.xcor()}, Player x: {int(player.xcor())}, Car y: {car.ycor()}, " f"Player y: {player.ycor()}, ") scoreboard.game_over() game_is_on = False cars.generate_new_car()
def setup(): """ common setup returns Turtle() and Screen() object """ wn = Screen() wn.setup(300, 300) wn.clear() turtle.delay(0) travis = Turtle() travis.hideturtle() travis.speed(0) return travis, wn
def main(): app = Screen() app.reset() app.clear() setup_app(app) app.tracer(0) snake = Snake() change_snake_colors(app, snake) app.listen() play_game(app, snake) app.mainloop()
def play(): race_on = False screen = Screen() screen.setup(width=500,height=400) user_bet = screen.textinput(title="Make your bet....",prompt="Which turtle will win the race? Enter a color: ") colors = ["red","green","blue","orange","purple","black"] y_cor = [-150,-100,-50,0,50,100,-150] turtles = [] for i in range(len(colors)) : temp = Turtle(shape="turtle") temp.penup() temp.color(colors[i]) temp.goto(x=-200,y=y_cor[i]) turtles.append(temp) if user_bet: race_on = True while (race_on): for i in range(len(turtles)): if turtles[i].xcor()>200: winning = turtles[i].pencolor() if winning.lower()==user_bet.lower(): print("") play_again = screen.textinput(title="Game over, Your turtle has won the race!!!!!", prompt="Do you want to play again? Type yes or no.") else: print("Your turtle lost, consider betting on a rabbit next time.") play_again = screen.textinput(title="Game over, Your turtle lost.", prompt="Consider betting on a rabbit next time. Do you want to play again? Type yes or no.") if play_again.lower() == "yes": screen.clear() play() race_on = False rand_dist = random.randint(0, 10) turtles[i].forward(rand_dist) screen.exitonclick()
def main(): screen = Screen() screen.setup(width=600, height=600) screen.bgcolor('black') screen.tracer(0) screen.title('Turtle Crossing') screen.colormode(255) scoreboard = Scoreboard() player = Player() car_manager = CarManager() screen.listen() screen.onkey(player.move_up, 'Up') screen.onkey(player.move_down, 'Down') screen.onkey(player.move_left, 'Left') screen.onkey(player.move_right, 'Right') game_is_on = True while game_is_on: time.sleep(0.1) screen.update() car_manager.create_car() car_manager.move_cars() for car in car_manager.all_cars: if car.distance(player) < 25: game_is_on = False scoreboard.game_over() play_again = screen.textinput( title="You lost bitch", prompt='Would you like to play again?').lower() if play_again[0] == 'y': screen.clear() main() else: screen.bye() if player.ycor() > 280: scoreboard.increase_level() player.player_reset() screen.exitonclick()
def game(lvl): # Screen Setup screen = Screen() screen.setup(width=600, height=600) screen.tracer(0) screen.colormode(255) # Turtle Setup player = Player() # Scoreboard Setup scoreboard = Scoreboard(lvl) # Car Manager Setup car_manager = CarManager(lvl) # Control listeners screen.listen() screen.onkeypress(fun=player.move_up, key="Up") screen.onkeypress(fun=player.move_down, key="Down") screen.onkeypress(fun=player.move_left, key="Left") screen.onkeypress(fun=player.move_right, key="Right") # Main Game Loop is_game = True while is_game: screen.update() time.sleep(0.1) car_manager.move_cars() if player.ycor() > 290: screen.clear() lvl += 2 game(lvl) for car in car_manager.cars_list: if player.distance(car) < 20: scoreboard.game_over() is_game = False screen.exitonclick()
def main(): wn = Screen() wn.setup(300, 300) wn.clear() #turtle.delay(0) travis = Turtle() travis.hideturtle() travis.speed(0) travis.penup() travis.goto(-150, 150) travis.pendown() travis.width(2) for x in range(-150, 150, 20): for y in range(-150, 150, 3): random_switch = random.randint(0, 1) if random_switch == 1: travis.forward(random.randint(5, 40)) travis.right(90) travis.forward(random.randint(5, 10)) travis.penup() travis.goto(x, y) travis.pendown() else: travis.backward(random.randint(5, 40)) travis.left(90) travis.backward(random.randint(5, 10)) travis.penup() travis.goto(x, y) travis.pendown() random_int = random.randint(0, 10) if random_int == 10: travis.color('red') else: travis.color('black') now = datetime.today().strftime('%Y-%m-%d-%H:%M:%S') turtle.getcanvas().postscript(file=f"circles_{now}.eps") wn.exitonclick()
def move_left(): timmy_the_turtle.left(10) def move_right(): timmy_the_turtle.right(10) def myclear_screen(): timmy_the_turtle.clear() timmy_the_turtle.home() timmy_the_turtle.penup() timmy_the_turtle.pendown() def try_listen(): my_screen.listen() my_screen.onkey(key="w", fun=move_forward) my_screen.onkey(key="s", fun=move_backword) my_screen.onkey(key="a", fun=move_left) my_screen.onkey(key="d", fun=move_right) my_screen.onkey(key="c",fun=myclear_screen) my_screen.exitonclick() #make_squre() #make_dashline() #draw_shape() #random_walk() #try_listen() my_screen.clear() race()
def go_again(): from turtle import Turtle, Screen import random # Size on screen size = 2 # screen declaration and canvas size screen = Screen() screen.setup(width=(500 * size), height=(400 * size)) # Turtle Attributes colors = ["purple", "red", "yellow", "blue", "orange", "green", "cyan"] # Turtle Colors colors_attribute = [ "purple", "red", "yellow", "blue", "orange", "green", "cyan" ] # Turtle Y axis starting position position = -150 # Turtle attributes, generated with the names in the colors list for x in range(len(colors)): colors[x] = Turtle() colors[x].hideturtle() colors[x].penup() colors[x].speed(10) colors[x].shape("turtle") colors[x].color(colors_attribute[x]) colors[x].shapesize((1.5 * size)) colors[x].goto(x=-200 * size, y=position * size) colors[x].showturtle() position += 50 # User bet, prompt user_bet = screen.textinput( title="Make your bet", prompt=("Which turtle will win the race? Enter Color between \n" f"{colors_attribute}: ")) x = 0 while 1 > x: for turtle in colors: if turtle.xcor() > (220 * size): x += 1 winning_turtle = turtle.pencolor() if winning_turtle == user_bet: print( f"You've won, the winning turtle was {turtle.pencolor()}" ) user_play_again = screen.textinput( title="Play again", prompt=f"You won, The winning turtle was " f"{turtle.pencolor()} " f"Do you want to play again? y / n: ") else: print(f"You lost, winning turtle was {turtle.pencolor()}") user_play_again = screen.textinput( title="Play again", prompt=f"You lost, the winning turtle was " f"{turtle.pencolor()} " f"Do you want to play again? y / n: ") if user_play_again == "y": screen.clear() go_again() random_pace = random.randint(0, 10) turtle.forward(random_pace) screen.exitonclick()
class Application: def __init__(self): self.screen_size = (600, 600) self.some_randomvalue_idk = 0 self.window = Screen() self.window.setup(height=700, width=700) self.window.tracer(0, 0) self.window.bgcolor("black") self.writer = Turtle() self.writer.hideturtle() self.writer.color("blue") self.gui_maker = Turtle() self.gui_maker.hideturtle() self.make_gui() self.player1 = Light_Turtle(color="red", facing="right", start_point=(-100, 0)) self.player1_score = 0 self.player2 = Light_Turtle(color="blue", facing="left", start_point=(100, 0)) self.player2_score = 0 self.window.title("Turtle Tron") self.colors = ("green", "yellow", "white") self.powerup1 = Turtle(shape="circle") self.powerup2 = Turtle(shape='circle') self.powerup3 = Turtle(shape='circle') self.powerup1.turtlesize(.5) self.powerup2.turtlesize(.5) self.powerup3.turtlesize(.5) self.powerup_t = (self.powerup1, self.powerup2, self.powerup3) self.powerup_coords = [] self.powerups = ("speed", "clear", "invis") self.window.update() def start(self): while True: try: ans = self.window.textinput( "Start", "Press enter when you are ready to begin, type 'q' to quit." ).lower() except AttributeError: break if ans == 'q' or ans == 'quit': break else: self.restart() self.run() self.writer.penup() self.writer.goto(0, 100) self.writer.pendown() self.window.update() self.window.clear() self.writer.penup() self.writer.goto(0, 0) self.writer.pendown() self.writer.write( f"Player 1: {self.player1_score}\tPlayer 2: {self.player2_score}", font=("Times New Roman", 36, "bold"), align='center') if self.player1_score == self.player2_score: try: name1 = self.window.textinput( "Finish!", "Please enter a name for the leaderboards, Player 1" ).lower() name2 = self.window.textinput( "Finish!", "Please enter a name for the leaderboards, Player 2" ).lower() except AttributeError: return with open(JSON_LINK, 'r') as f: data = json.load(f) data[GAME_ID] = {} data[GAME_ID]['player1'] = name1 data[GAME_ID]['p1score'] = self.player1_score data[GAME_ID]['player2'] = name2 data[GAME_ID]['p2score'] = self.player2_score with open(JSON_LINK, 'w') as f: json.dump(data, f) elif self.player1_score > self.player2_score: try: name1 = self.window.textinput( "Finish!", "Please enter a name for the leaderboards, Player 1" ).lower() name2 = self.window.textinput( "Finish!", "Please enter a name for the leaderboards, Player 2" ).lower() except AttributeError: return with open(JSON_LINK, 'r') as f: data = json.load(f) data[GAME_ID] = {} data[GAME_ID]['player1'] = name1 data[GAME_ID]['p1score'] = self.player1_score data[GAME_ID]['player2'] = name2 data[GAME_ID]['p2score'] = self.player2_score with open(JSON_LINK, 'w') as f: json.dump(data, f) elif self.player2_score > self.player1_score: try: name1 = self.window.textinput( "Finish!", "Please enter a name for the leaderboards, Player 1" ).lower() name2 = self.window.textinput( "Finish!", "Please enter a name for the leaderboards, Player 2" ).lower() except AttributeError: return with open(JSON_LINK, 'r') as f: data = json.load(f) data[GAME_ID] = {} data[GAME_ID]['player1'] = name1 data[GAME_ID]['p1score'] = self.player1_score data[GAME_ID]['player2'] = name2 data[GAME_ID]['p2score'] = self.player2_score with open(JSON_LINK, 'w') as f: json.dump(data, f) def run(self): self.place_powerups() self.writer.clear() self.window.update() self.some_randomvalue_idk += 1 self.count_down() self.window.onkey(lambda: self.player2.left(90), "Left") self.window.onkey(lambda: self.player2.right(90), "Right") self.window.onkey(lambda: self.player1.left(90), "a") self.window.onkey(lambda: self.player1.right(90), "d") self.window.listen() t1 = time() t2 = time() while True: elapsed = t2 - t1 if elapsed > 1 / TARGET_FPS: t1 = t2 self.player1.forward(TURTLE_SPEED) self.player2.forward(TURTLE_SPEED) self.check_walls() self.check_light_walls() self.player1.wall_add() self.player2.wall_add() self.window.update() if not self.player1.alive or not self.player2.alive: self.display_winner() self.writer.clear() self.window.update() self.writer.penup() self.writer.goto(0, 100) self.window.update() return t2 = time() self.window.mainloop() def restart(self): self.writer.clear() self.window.update() self.player1.alive = True self.player2.alive = True self.player1.showturtle() self.player2.showturtle() self.player1.clear() self.player2.clear() self.player1.penup() self.player2.penup() self.player1.goto(self.player1.start_point) self.player2.goto(self.player2.start_point) self.player1.seth(self.player1.facing) self.player2.seth(self.player2.facing) self.player1.color(self.player1.colorv) self.player2.color(self.player2.colorv) self.player1.pendown() self.player2.pendown() self.player1.wall.clear() self.player2.wall.clear() self.window.update() def gui_goto(self, x, y): self.gui_maker.penup() self.gui_maker.goto(x, y) self.gui_maker.pendown() def make_gui(self): self.gui_maker.color("red") self.gui_maker.pensize(15) x, y = self.screen_size self.gui_goto(x / 2, y / 2) self.gui_maker.seth(270) for _ in range(4): self.gui_maker.fd(x) self.gui_maker.rt(90) self.window.update() def count_down(self): self.writer.penup() self.writer.home() self.writer.pendown() timer = 3 for _ in range(4): self.writer.write(timer, font=("Times New Roman", 24, "bold"), align="center") sleep(1) timer -= 1 self.writer.clear() def check_walls(self): p1x, p1y = self.player1.position() p2x, p2y = self.player2.position() wallx, wally = self.screen_size wallx /= 2 wally /= 2 if p1x >= wallx or p1x <= -wallx or p1y <= -wally or p1y >= wally: self.player1.alive = False if p2x >= wallx or p2x <= -wallx or p2y <= -wally or p2y >= wally: self.player2.alive = False def check_light_walls(self): p1c = self.player1.position() p1w = self.player1.wall p2c = self.player2.position() p2w = self.player2.wall if p1c == p2c: self.player1.alive = False self.player2.alive = False if p1c in p1w or p1c in p2w: self.player1.alive = False if p2c in p1w or p2c in p2w: self.player2.alive = False def display_winner(self): self.writer.hideturtle() self.writer.penup() self.writer.goto(0, 245) self.writer.pendown() if self.player2.alive == False and self.player1.alive == False: self.writer.write("Tie!", font=("Times New Roman", 36, "bold"), align="center") self.writer.penup() self.writer.goto(0, 145) self.writer.pendown() self.writer.write( f"Player 1: {self.player1_score}\tPlayer 2: {self.player2_score}", font=("Times New Roman", 24), align="center") self.explode(self.player1, self.player2) elif self.player1.alive == False: self.writer.write("Player 2 has won!", font=("Times New Roman", 36, "bold"), align="center") self.player2_score += 1 self.writer.penup() self.writer.goto(0, 145) self.writer.pendown() self.writer.write( f"Player 1: {self.player1_score}\tPlayer 2: {self.player2_score}", font=("Times New Roman", 24), align="center") self.explode(self.player1) elif self.player2.alive == False: self.writer.write("Player 1 has won!", font=("Times New Roman", 36, "bold"), align="center") self.player1_score += 1 self.writer.penup() self.writer.goto(0, 145) self.writer.pendown() self.writer.write( f"Player 1: {self.player1_score}\tPlayer 2: {self.player2_score}", font=("Times New Roman", 24), align="center") self.explode(self.player2) def explode(self, turtle1, turtle2=None): i = 1 if turtle2 == None: turtle1.hideturtle() for _ in range(39): if i % 20 == 0: i = 0 turtle1.seth(270) turtle1.bk(20) if i % 2 == 0: turtle1.color("yellow") else: turtle1.color("orange") turtle1.begin_fill() turtle1.seth(270) turtle1.forward(1) turtle1.seth(0) turtle1.circle(i * 1) turtle1.end_fill() sleep(.1) self.window.update() i += 1 else: turtle1.hideturtle() turtle2.hideturtle() for _ in range(39): if i % 20 == 0: i = 0 turtle1.seth(270) turtle2.seth(270) turtle1.bk(20) turtle2.bk(20) if i % 2 == 0: turtle1.color("orange") turtle2.color("orange") else: turtle1.color("yellow") turtle2.color("yellow") turtle1.begin_fill() turtle2.begin_fill() turtle1.seth(270) turtle2.seth(270) turtle1.fd(1) turtle2.fd(1) turtle1.seth(0) turtle2.seth(0) turtle1.circle(i * 1) turtle2.circle(i * 1) turtle1.end_fill() turtle2.end_fill() sleep(.1) self.window.update() i += 1 def place_powerups(self): for turtle in self.powerup_t: ranx = randint(-250, 250) rany = randint(-250, 250) turtle.penup() turtle.goto(ranx, rany) turtle.pendown() turtle.color(choice(self.colors)) self.window.update()
screen.update() time.sleep(0.05) snake.move() #Detect collision with food. if snake.head().distance(food) < 15: food.refresh() score.refresh(1) snake.extend( ) #Detect collision with the wall if snake.head().xcor() > 280 or snake.head().xcor() < -280 or snake.head().ycor() > 280 or snake.head().ycor() < -280: #snake.game_is_on = False score.game_over() time.sleep(2) screen.clear() set_screen(screen, snake) snake.reset() food = Food() if score.score > score.high_score: score.high_score = score.score score.score = 0 with open("high_score.txt", mode="w") as file: file.write(str(score.high_score)) else: score.score = 0 score.refresh(0) #Detect collision with tail for segment in snake.segments[1:]: #if segment == snake.head():
def main(): # initialize screen screen = Screen() screen.title("Snake") screen.tracer(0) # ask for user inputs for window size and snake speed chosen_grid = screen.textinput( "Welcome to Snake!", "Choose a window size (small/medium/big): ") insane_choice = screen.textinput("Welcome to Snake!", "Insane mode? (yes/no)") if insane_choice == "yes": speed = 1 insane_mode = True else: speed = screen.numinput("Welcome to Snake!", f"Choose a speed (1-{len(speeds)}): ") insane_mode = False # initialize food, snake and scoreboard chosen_size = grids[chosen_grid]["size"] food = Food(grids[chosen_grid]["grid"]) snake = Snake(chosen_size) scoreboard = ScoreBoard(chosen_size) if insane_mode: insane_writer = InsaneMode(chosen_size) # setup screen of the chosen size, color, title width = height = grids[chosen_grid]["size"] screen.setup(width=width, height=height) screen.bgcolor("black") screen.title("Snake") # updates screen to show snake, first food piece and scoreboard screen.update() # main loop # stops when snake collides with itself or obstacles while snake.is_alive(): # checks for collision with food and updates food position if necessary # also increments scoreboard score according to difficulty if snake.head.distance(food) < 15: snake.lenght += 1 food.update() scoreboard.score += int(grids[chosen_grid]["multiplier"] * speed) # increments difficulty on insane mode if insane_mode and speed < 12: speed += 1 insane_writer.level += 1 # listen to user key presses screen.listen() screen.onkey(fun=snake.turnUp, key="Up") screen.onkey(fun=snake.turnDown, key="Down") screen.onkey(fun=snake.turnLeft, key="Left") screen.onkey(fun=snake.turnRight, key="Right") screen.onkey(fun=screen.bye, key="Escape") # update snake, scoreboard, insane lvl and screen snake.update() scoreboard.update() screen.update() if insane_mode: insane_writer.update() # loop delay / speed control time.sleep(speeds_dict[speed]) # game over screen scoreboard.game_over() screen.textinput("Game Over", "Press any key to play again") snake.reset() scoreboard.reset() screen.clear() main()
class TurtlePlot: def __init__(self, width, height, title=""): """ Initialize a Turtle Plot Args: width: Width of the screen height: Height of the screen """ self.width = width self.height = height self.title = title self.screen = Screen() self.screen.clear() self.screen.setup(width=width, height=height) self.screen.setworldcoordinates(0, 0, width, height) self.screen.tracer(0, 1) self.screen.onclick(lambda x, y: self.zoom_in(x, y)) self.screen.title(self.title + " (click to zoom in)") def done(self): """ Wait until user clicks or closes screen. """ self.screen.mainloop() def _setworldcoordinates(self, xmin, ymin, xmax, ymax): try: self.screen.setworldcoordinates(xmin, ymin, xmax, ymax) except Exception as e: pass def zoom_in(self, x, y): self._setworldcoordinates(x - 50, y - 50, x + 50, y + 50) self.screen.onclick(lambda x, y: self.zoom_out()) self.screen.title(self.title + " (click to zoom out)") def zoom_out(self): self._setworldcoordinates(0, 0, self.width, self.height) self.screen.onclick(lambda x, y: self.zoom_in(x, y)) self.screen.title(self.title + " (click to zoom in)") def draw(self, plot_record: PlotRecord, x_bounds, y_bounds): """ Draw a plot on the turtle screen. Args: plot_record: The plot record to display. x_bounds: The plots x bounds y_bounds: The plots y bounds """ outline_turtle = Turtle() outline_turtle.hideturtle() xy_turtles = [Turtle() for _ in plot_record.xys] for i, trtl in enumerate(xy_turtles): trtl.penup() trtl.pensize(2) trtl.pencolor(plot_record.xys[i].color) trtl.hideturtle() turtle_xmin, turtle_xmax = x_bounds turtle_ymin, turtle_ymax = y_bounds turtle_dx = turtle_xmax - turtle_xmin turtle_dy = turtle_ymax - turtle_ymin # leave 20% space on left and bottom # for labeling turtle_margin_left = 0.2 turtle_margin_right = 0.2 turtle_margin_bottom = 0.3 turtle_margin_top = 0.3 turtle_x_chart_min = turtle_xmin + (turtle_dx * turtle_margin_left) turtle_y_chart_min = turtle_ymin + (turtle_dy * turtle_margin_bottom) turtle_x_chart_max = turtle_xmax - (turtle_dx * turtle_margin_right) turtle_y_chart_max = turtle_ymax - (turtle_dy * turtle_margin_top) turtle_dx_chart = turtle_x_chart_max - turtle_x_chart_min turtle_dy_chart = turtle_y_chart_max - turtle_y_chart_min fontsize = 8 outline_turtle.penup() outline_turtle.setposition( turtle_xmin, (turtle_y_chart_min + turtle_y_chart_max) * 0.5) outline_turtle.write(plot_record.ylabel) outline_turtle.setposition(turtle_x_chart_min, turtle_y_chart_max) outline_turtle.pendown() outline_turtle.setposition(turtle_x_chart_min, turtle_y_chart_min) outline_turtle.setposition(turtle_x_chart_max, turtle_y_chart_min) outline_turtle.penup() all_xs = [x for xy in plot_record.xys for x in xy.x] all_ys = [y for xy in plot_record.xys for y in xy.y] series_xmin = min(all_xs) series_xmax = max(all_xs) series_ymin = min(all_ys) series_ymax = max(all_ys) series_dx = (series_xmax - series_xmin) or 1 series_dy = (series_ymax - series_ymin) or 1 # scale factor from series to turtle xscale = turtle_dx_chart / series_dx yscale = turtle_dy_chart / series_dy outline_turtle.setposition(turtle_x_chart_min - fontsize, turtle_y_chart_max - (fontsize * 0.5)) outline_turtle.write("%0.02f" % series_ymax, align='right') outline_turtle.setposition( turtle_x_chart_min - fontsize, turtle_y_chart_min + (turtle_dy_chart * 0.5) - (fontsize * 0.5)) outline_turtle.write("%0.02f" % ((series_ymin + series_ymax) * 0.5), align='right') outline_turtle.setposition(turtle_x_chart_min - fontsize, turtle_y_chart_min - (fontsize * 0.5)) outline_turtle.write("%0.02f" % series_ymin, align='right') outline_turtle.setposition(turtle_x_chart_max, turtle_y_chart_min - (fontsize * 2)) outline_turtle.write("%0.02f" % series_xmax, align='center') outline_turtle.setposition( turtle_x_chart_min + (turtle_dx_chart * 0.5) - fontsize, turtle_y_chart_min - (fontsize * 2)) outline_turtle.write("%0.02f" % ((series_xmin + series_xmax) * 0.5), align='center') outline_turtle.setposition(turtle_x_chart_min, turtle_y_chart_min - (fontsize * 2)) outline_turtle.write("%0.02f" % series_xmin, align='center') for i, xy in enumerate(plot_record.xys): # position turtle at first xy value xy_turtles[i].setposition( turtle_x_chart_min + (xscale * (xy.x[0] - series_xmin)), turtle_y_chart_min + (yscale * (xy.y[0] - series_ymin))) xy_turtles[i].pendown() for j in range(min(len(xy.x), len(xy.y))): xy_turtles[i].setposition( turtle_x_chart_min + (xscale * (xy.x[j] - series_xmin)), turtle_y_chart_min + (yscale * (xy.y[j] - series_ymin))) xy_turtles[i].penup() xy_turtles[i].setposition(turtle_x_chart_max + (fontsize * 2), turtle_y_chart_max - (fontsize * 2 * i)) xy_turtles[i].write(xy.label, align='left')
t.sety(-font_size/2) font = ("Times", font_size, "bold") # TODO make these function calls correct = 0 for a in abc: t.write(a, font=font) guess = input("Which letter this this? ") if guess.lower() == a[0].lower(): print("Yes!") correct += 1 else: print("Sorry =[") s.clear() print(f"Score: {correct}") print(round(correct * 100 / len(abc)), "%") correct = 0 for n in nums: t.write(i, font=font) guess = input("What number is this?") if guess == str(n): print("Yes!") correct += 1 else: print("Sorry =[") s.clear()
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 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]
def play_game(user_bank): screen = Screen() screen.setup(width=500, height=400) is_race_on = False turtles = [] pos_y = -100 color_index = 0 for turtle_index in range(0, 6): odds_move = random.randint(5, 15) odds_money = round(20/odds_move, 2) new_turtle = Turtle("turtle") new_turtle.color(colors[color_index]) new_turtle.penup() new_turtle.goto(-230, pos_y) pos_y += 50 color_index += 1 turtles.append((new_turtle, odds_money, odds_move)) bet_prompt = f"Who is going to win? Odds:\n" \ f"Red: {turtles[0][1]}\n" \ f"Blue: {turtles[1][1]}\n" \ f"Yellow: {turtles[2][1]}\n" \ f"Green: {turtles[3][1]}\n" \ f"Purple: {turtles[4][1]}\n" \ f"Orange: {turtles[5][1]}\n" money_prompt = f"You currently have ${user_bank}, How much would you like to bet?" user_bet_horse = screen.textinput(title="Make your bet", prompt=bet_prompt).lower() user_bet_money = int(screen.numinput(title="How much?", prompt=money_prompt)) if user_bet_horse: is_race_on = True while is_race_on: for turtle in turtles: if turtle[0].xcor() > 230: is_race_on = False win_color = turtle[0].fillcolor() odds_money = turtle[1] odds_move = turtle[2] if win_color == user_bet_horse: user_bank += (user_bet_money * odds_money) win_prompt = f"You won ${user_bet_money * (20 - odds_money)}! The {win_color} turtle with odds of" \ f" {odds_money} won!\nWould you like to place another bet? Yes or No\n" if screen.textinput(title="YOU WON :)", prompt=win_prompt).lower() == "yes": screen.clear() play_game(user_bank) else: screen.bye() else: user_bank -= user_bet_money lose_prompt = f"You lost ${user_bet_money}! The {win_color} turtle with odds of {odds_money} won!" \ f"\n(press enter to continue)\nWould you like to place another bet? Yes or No\n" if screen.textinput(title="YOU LOST :(", prompt=lose_prompt).lower() == "yes": screen.clear() play_game(user_bank) else: screen.bye() distance = random.randint(0, odds_move) turtle[0].fd(distance)