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)
