예제 #1
0
def main():
    screen = Screen()
    screen.setup(width=500, height=800)
    user_bet = turtles_colors.index(
        screen.textinput(title="Make your bet",
                         prompt="Which turtle color will win?"))
    start_position = 0
    for turtle in turtles_colors:
        color = turtle
        turtle = Turtle()
        turtles.append(turtle)
        turtle.penup()
        turtle.color(color)
        turtle.shape("turtle")
        turtle.setposition(
            ((-int(screen.window_width() / 2) + 40),
             int(screen.window_height() / 2) - 50 - start_position))
        start_position += 30

    winner = race((int(screen.window_width() / 2) - 40))
    for turtle in turtles:
        print(turtles_colors[turtles.index(turtle)].title() +
              " finished at: " + str(turtle.position()[0]))
    check_win(winner, user_bet)

    screen.exitonclick()
예제 #2
0
def set_up(axis=True, bgcolor='white'):
    s = Screen()
    s.setup(700, 700)
    s.bgcolor(bgcolor)
    if axis:
        axis_drawer = Turtle()
        axis_drawer.color('#A4AEF3')
        axis_drawer.speed('fastest')
        axis_drawer.penup()
        axis_drawer.goto(-s.window_width() / 2 + 30, 0)
        axis_drawer.pendown()
        axis_drawer.goto(s.window_width() / 2 - 30, 0)
        axis_drawer.stamp()
        axis_drawer.penup()
        axis_drawer.goto(0, -s.window_height() / 2 + 30)
        axis_drawer.setheading(90)
        axis_drawer.pendown()
        axis_drawer.goto(0, s.window_height() / 2 - 30)
        axis_drawer.stamp()
        axis_drawer.penup()
        axis_drawer.hideturtle()
        axis_drawer.goto(-s.window_width() / 2 + 30, 5)
        axis_drawer.write(f"-{int(s.window_width() / 2)}")
        axis_drawer.goto(s.window_width() / 2 - 50, 5)
        axis_drawer.write(f"+{int(s.window_width() / 2)}", )
        axis_drawer.goto(5, -s.window_height() / 2 + 30)
        axis_drawer.write(f"-{int(s.window_height() / 2)}")
        axis_drawer.goto(5, s.window_height() / 2 - 30)
        axis_drawer.write(f"+{int(s.window_height() / 2)}")

    return s
예제 #3
0
class PongGame:
    def __init__(self):
        self.running = True

        self.screen = Screen()
        self.screen.setup(width=900, height=900)
        self.boundaries = {
            "ceiling": self.screen.window_height() // 2 - 60,
            "right_wall": self.screen.window_width() // 2 - 30,
            "floor": self.screen.window_height() // -2 + 60,
            "left_wall": self.screen.window_width() // -2 + 30
        }

        self.player1 = Paddle("left", self.boundaries)
        self.player2 = Paddle("right", self.boundaries)

        self.ball = Ball(self.boundaries, (self.player1, self.player2))

        self.scoreboard = Scoreboard()

        self.screen.onkeypress(self.player1.move_up, "w")
        self.screen.onkeypress(self.player1.move_down, "s")
        self.screen.onkeypress(self.player2.move_up, "Up")
        self.screen.onkeypress(self.player2.move_down, "Down")
        self.screen.onkeyrelease(self.player1.stop, "w")
        self.screen.onkeyrelease(self.player1.stop, "s")
        self.screen.onkeyrelease(self.player2.stop, "Up")
        self.screen.onkeyrelease(self.player2.stop, "Down")
        self.screen.listen()

    def run(self):
        self.ball.tick()
        self.player1.tick()
        self.player2.tick()

        if self.ball.xcor()-1 <= self.boundaries["left_wall"]:
            self.scoreboard.player2()
            self.ball.start_over()
        elif self.ball.xcor()+1 >= self.boundaries["right_wall"]:
            self.scoreboard.player1()
            self.ball.start_over()
        elif (self.ball.ycor() >= self.boundaries["ceiling"] or
                self.ball.ycor() <= self.boundaries["floor"]):
            self.ball.y_direction *= -1
        elif self.ball.xcor() < 0:
            player_x, player_y = self.player1.position()
            if self.ball.xcor() <= player_x and self.ball.ycor() <= player_y + 69 and self.ball.ycor() >= player_y - 69:
                self.ball.x_direction *= -1
        else:
            player_x, player_y = self.player2.position()
            if self.ball.xcor() >= player_x and self.ball.ycor() <= player_y + 69 and self.ball.ycor() >= player_y - 69:
                self.ball.x_direction *= -1

        if self.scoreboard.player1score >= 3 or self.scoreboard.player2score >= 3:
            self.scoreboard.game_over()
            self.running = False

        if self.running:
            self.screen.ontimer(self.run, 1)
예제 #4
0
def turtle_race():
    screen = Screen()
    distance = []
    screen.setup(width=500, height=400)
    right_width_limit = screen.window_width() - 35
    turtles = [("blue", Turtle(shape="turtle")),
               ("red", Turtle(shape="turtle")),
               ("green", Turtle(shape="turtle")),
               ("yellow", Turtle(shape="turtle")),
               ("black", Turtle(shape="turtle"))]
    for i in range(len(turtles)):
        turtle = turtles[i][1]
        distance.append(0)
        turtle.speed(4)
        turtle.color(turtles[i][0])
        turtle.penup()
        turtle.goto(x=-240, y=100 - 50 * i)
    bet = screen.textinput(
        "MAKE THE BET", prompt="Select the color of winning turtle").lower()

    while max(distance) <= right_width_limit:
        for i in range(len(turtles)):
            step = randint(1, 10)
            turtles[i][1].forward(step)
            distance[i] += step
    if bet == turtles[distance.index(max(distance))][0]:
        print("YOU WON")
    else:
        print(
            f"You lost the bet,{turtles[distance.index(max(distance))][0]} won the race"
        )

    screen.exitonclick()
예제 #5
0
class Drawer:
    def __init__(self, amount: int):

        self.screen = Screen()
        self.screen.bgcolor("black")
        self.screen.screensize(canvwidth=512, canvheight=512)
        self.w = self.screen.window_width()
        self.h = self.screen.window_height()

        t = Turtle()
        draw_background(t)

        atexit.register(self.save)
        self.pointers = [Pen(self.w, self.h) for _ in range(amount)]

    def save(self):
        print("SAVING!!!!!!!!!")
        # get the current screen
        ts = self.pointers[0].t1.getscreen()
        # save the drawing to a post script
        ts.getcanvas().postscript(file="art_save.eps")

    def start(self):
        while True:
            for i in self.pointers:
                i.draw()
            turtle.update()
예제 #6
0
 def __init__(self, screen: Screen):
     super(Scoreboard, self).__init__()
     self.speed("fastest")
     self.color("white")
     self.playerAScore = 0
     self.playerBScore = 0
     self.hideturtle()
     self.playerALocation = (-screen.window_width() / 2, screen.window_height() / 2)
     self.playerBLocation = (-screen.window_width() / 2, screen.window_height() / 2)
     self.__display_score()
예제 #7
0
def main():
    image = 'spots.jpg'
    rgbs = get_colors(image, 30)

    turtle = Turtle()
    screen = Screen()
    turtle.speed(20)
    turtle.penup()
    turtle.setpos(-screen.window_width(), -300)
    draw_dots(turtle, screen, rgbs)

    screen.exitonclick()
예제 #8
0
class Game():
    def __init__(self):
        self.win = Screen()
        self.win.bgcolor('pink')
        # self.win.setup(width=w, height=h, startx=None, starty=None)

        self.border = Border()
        width, height = self.win.window_width(), self.win.window_height()
        print(width, height)
        self.border.draw_self((width, height))

        self.turtle = Arrow()
        self.win.onkey(self.quit, 'q')
        self.win.onkey(self.arrow_left, 'Left')
        self.win.onkey(self.arrow_right, 'Right')
        self.win.onkey(self.arrow_up, 'Up')
        self.win.onkey(self.arrow_down, 'Down')
        self.win.listen()

        self.win.onclick(self.check_coord)

        self.increase_speed()
        self.move_arrow()

    def check_coord(self, x, y):
        print(x, y)

    def quit(self):
        self.win.bye()

    def move_arrow(self):
        self.turtle.move()
        self.win.ontimer(self.move_arrow, 50)

    def arrow_left(self):
        self.turtle.turn_left()

    def arrow_right(self):
        self.turtle.turn_right()

    def arrow_up(self):
        self.turtle.turn_up()

    def arrow_down(self):
        self.turtle.turn_down()

    def increase_speed(self):
        self.turtle.speedup()
        self.win.ontimer(self.increase_speed, 3000)

    def main(self):
        self.win.mainloop()
예제 #9
0
    def __init__(self, screen: Screen):
        self.screen = screen
        self.width = screen.window_width() - 2 * OFFSET
        self.height = screen.window_height() - 2 * OFFSET - SCORE_SPACE
        self.turtle = Turtle()
        self.turtle.hideturtle()
        self.lanes = []
        self.player = Player(min_x=-self.width / 2,
                             max_x=self.width / 2,
                             min_y=-self.height / 2 + 10,
                             max_y=self.height / 2 - 10)
        self.game_over = GameOver()

        self.__prepare_listener()
        self.__prepare_field()
        self.__prepare_lanes()
        self.__prepare_game_over()
예제 #10
0
def fill_coordinate(coordinate,
                    num_rows,
                    num_columns,
                    fill_color="green",
                    space_from_edge=10):
    turtle.color(fill_color)
    turtle.fillcolor(fill_color)

    rows = num_rows + 1
    columns = num_columns + 1
    screen = Screen()
    width, height = screen.window_width(), screen.window_height()
    distanceX = width / columns
    distanceY = height / rows
    # x -> represents columns
    # y -> represents rows
    Y, X = coordinate[0], coordinate[1]

    # this is tested in MAC environment and the coordinate calculation is based on the mac-os display grid
    startX = -width / 2 + X * distanceX + space_from_edge
    startY = height / 2 - Y * distanceY - space_from_edge

    turtle.begin_fill()
    turtle.up()
    turtle.goto(startX, startY)
    turtle.down()
    # draw top
    turtle.forward(distanceX)
    # draw right
    turtle.right(90)
    turtle.forward(distanceY)
    # draw bottom
    turtle.right(90)
    turtle.forward(distanceX)
    # draw left
    turtle.right(90)
    turtle.forward(distanceY)
    turtle.right(90)
    turtle.end_fill()

    # reset colors back to default
    turtle.color("black")
    turtle.fillcolor("white")
    return []
예제 #11
0
파일: window.py 프로젝트: alexpdev/Games
class Window:
    def __init__(self, w=.9, h=.9, x=0, y=0):
        self.screen = Screen()
        self.screen.setup(w, h, x, y)
        self.screen.bgcolor("wheat")
        self.screen.colormode(255)
        self.screen_width = (((self.screen.window_width()) * .98) // 12) * 12
        self.screen_height = (((self.screen.window_height()) * .95) // 12) * 12
        self.width = self.screen_width / 2
        self.height = self.screen_height / 2

    def pen(self):
        turt = RawTurtle(self.screen)
        turt.ht()
        turt.speed(0)
        turt.up()
        turt.goto(-self.width, self.height)
        turt.down()
        return turt
예제 #12
0
def main():
    # Setup board and its components
    game_board = Screen()
    game_board.setup(width=800, height=600)
    game_board.bgcolor("black")
    game_board.tracer(0)
    game_board.listen()
    scoreboard = Scoreboard((0, game_board.window_height()/2-40))
    paddle_one = Paddle(((game_board.window_width()/2)-40, 25))
    paddle_two = Paddle((-(game_board.window_width()/2)+40, 25))
    ball = Ball()

    # Setup generic keys
    game_board.onkey(game_board.bye, "Escape")
    game_board.onkey(ball.increase_speed, "KP_Add")
    game_board.onkey(ball.decrease_speed, "KP_Subtract")
    # Setup player keys
    game_board.onkey(paddle_one.up, "Up")
    game_board.onkey(paddle_one.down, "Down")
    game_board.onkey(paddle_two.up, "q")
    game_board.onkey(paddle_two.down, "a")

    # Run the game
    game_is_on = True
    while game_is_on:
        game_board.update()
        time.sleep(ball.game_speed)
        ball.move()

        # bounce off top/bottom wall
        if ball.ycor() > (game_board.window_height()/2-20) or ball.ycor() < -game_board.window_height()/2+20:
            ball.change_direction()

        # hit paddle
        if (ball.xcor() > game_board.window_width()/2 - 70 and paddle_one.distance(ball) < 50) or \
                (ball.xcor() < -game_board.window_width()/2 + 70 and paddle_two.distance(ball) < 50):
            ball.change_direction(True)
            # Randomly increase the game speed a little
            if randint(0, 3) == 2:
                ball.game_speed *= 0.9

        # hit back wall and score point
        if ball.xcor() > game_board.window_width()/2 - 20:
            scoreboard.update_score(1)
            ball.reset_game()
        if ball.xcor() < -game_board.window_width()/2 + 20:
            scoreboard.update_score(0)
            ball.reset_game()

    game_board.exitonclick()
예제 #13
0
def get_screen():
    screen = Screen()
    screen.setup(*conf.SCREEN_SIZE)
    screen.bgcolor(conf.BACKGROUND)
    screen.tracer(conf.TRACER)
    screen.delay(conf.DELAY)
    screen.title(conf.TITLE)
    screen.speed = conf.SPEED
    screen.winheight = screen.window_height() * .95
    screen.winwidth = screen.window_width() * .95
    screen.width = screen.winwidth // 2
    screen.height = screen.winheight // 2
    screen.blockwidth = conf.BLOCK_WIDTH
    screen.increment = screen.blockheight = conf.BLOCK_HEIGHT
    screen.base = screen.height
    screen.start = -screen.width + screen.blockwidth
    screen.blocks = int(((screen.width * 2) - (screen.blockwidth * 2)) //
                        (screen.blockwidth + 1))
    screen.gradient = gradient(conf.GRADIENT, screen.blocks)
    return screen
예제 #14
0
def draw_graph(num_rows, num_columns, space_from_edge=10):
    columns = num_columns + 1
    rows = num_rows + 1
    screen = Screen()
    width, height = screen.window_width(), screen.window_height()

    x = -(width / 2 - space_from_edge)
    distanceX = width / columns
    for _ in range(columns):
        turtle.penup()
        turtle.goto(x, (height / 2))
        turtle.pendown()
        turtle.goto((x, -(height / 2)))
        x += distanceX

    y = height / 2 - space_from_edge
    distanceY = height / rows
    for _ in range(rows):
        turtle.penup()
        turtle.goto((width / 2), y)
        turtle.pendown()
        turtle.goto((-(width / 2)), y)
        y -= distanceY
예제 #15
0
파일: hip.py 프로젝트: razatkashyap/pycharm
def d():
    t.setheading(0)
    t.forward(100)

def right():
    t.setheading(0)
    t.forward(100)

def s():
    t.setheading(270)
    t.forward(100)

def down():
    t.setheading(270)
    t.forward(100)

screen =Screen()
screen.window_height()
screen.window_width()

screen.listen()
screen.onkey(up, "Up")
screen.onkey(down, "Down")
screen.onkey(left, "Left")
screen.onkey(right, "Right")
screen.onkeypress(a, "a")
screen.onkeypress(s, "s")
screen.onkeypress(w, "w")
screen.onkeypress(d, "d")

screen.mainloop()
예제 #16
0
while gameIsOn:
    screen.update()

    if playerOne.distance(ball) < 15:
        BALL_UP = True
        BALL_RIGHT = True
        BALL_DOWN = False
        BALL_LEFT = False
    elif playerTwo.distance(ball) < 15:
        BALL_DOWN = True
        BALL_LEFT = True
        BALL_UP = False
        BALL_RIGHT = False

    if ball.xcor() >= (screen.window_width() //
                       2) or ball.xcor() < (-1 * screen.window_width() // 2):
        ball.penup()
        ball.setpos(0, 0)
        randomNum = randrange(10)
        print(randomNum)
        if randomNum > 5:
            BALL_UP = True
            BALL_RIGHT = True
            BALL_DOWN = False
            BALL_LEFT = False
        else:
            BALL_UP = True
            BALL_LEFT = True
            BALL_DOWN = False
            BALL_RIGHT = False
예제 #17
0
Simple version of the classic Asteroids video game.
Implemented with Turtle graphics from Python standard turtle module.

Adapted from "Python Programming Fundamentals" by Kent Lee
http://knuth.luther.edu/~leekent/IntroToComputing/
"""

from time import sleep

from turtle import Turtle, Screen
import turtle
import random
import math

screen = Screen()
screenMinX = -screen.window_width() / 2
screenMinY = -screen.window_height() / 2
screenMaxX = screen.window_width() / 2
screenMaxY = screen.window_height() / 2

screen.setworldcoordinates(screenMinX, screenMinY, screenMaxX, screenMaxY)
screen.bgcolor("black")

offscreen_x = screenMinX - 100

t = Turtle()
t.penup()
t.ht()
t.speed(0)
t.goto(0, screenMaxY - 20)
t.color('grey')
예제 #18
0
# Нарисуйте «бабочку» из окружностей. Используйте функцию, рисующую окружность.
import time

from turtle import Turtle, Screen

count = 8
screen = Screen()
WIDTH = screen.window_width()

turtle = Turtle(visible=False)

turtle.shape('turtle')

turtle.penup()       
turtle.goto(-WIDTH/2 + 200, 0)
turtle.pendown()

turtle.right(-90) 

for _ in range(count):
    turtle.circle(-50, 180)
    turtle.circle(-10, 180)

time.sleep(1)
예제 #19
0
                # 180 degrees means "draw a semicircle"
                self.t.circle(5 * ss / 2, 180)
                c = bw
                spr.addCurr(c)
            else:
                self.t.setheading(270)  # 270 degrees is straight down
                self.t.circle(5 * ss / 2, 180)
                c += ss
                spr.addCurr(c)
        # mandelbrot = Mandelbrot()
        #
        # for x in range(-150, 255):
        #     for y in range(-150, 255):
        #         mandelbrot.computeCardinality(turtleConvert(x, y))
        #         self.t.color(mandelbrot.getColor())
        #         self.t.goto(x, y)
        #     self.t.up()
        #     self.t.goto(x+1, -150)
        #     self.t.down()
        #     screen.update()


def turtleConvert(x, y):  # converts from turtle pixels to the complex plane
    return complex(x / 100, y / 100)


screen = Screen()
dummy = Display(screen, 1 / 2 - screen.window_width() / 2,
                screen.window_height() / 2 - 1 / 2)
screen.mainloop()
예제 #20
0
from turtle import Turtle, Screen
# import another_module
franklin = Turtle()
# my_number = another_module.another_variable
my_screen = Screen()

franklin.shape('turtle')
franklin.color('green', 'black')
franklin.isvisible()
franklin.forward(99)
print(my_screen.canvheight)
print(my_screen.window_width())
my_screen.exitonclick()

from prettytable import PrettyTable
table = PrettyTable()
table.add_column('Pokemon Name', ['Pikachu', 'Squirtle', 'Charmander'])
table.add_column('Type', ['Electric', 'Water', 'Fire'])

table.align = "l"

print(table)
예제 #21
0

def generate_25_dots_with_5_per_line():
    # 5 dots per line
    # default is pointing north, turn it to east
    leonardo.right(90)

    overall_height = screen.canvheight.real
    overall_width = screen.canvwidth.real


number_of_lines = int(input("How many number of lines do you want to draw? "))
number_of_dots_per_line = int(input("How many number of dots per line? "))

dot_size = 10
v_spacing = (screen.window_height()) / (number_of_lines + 1)
h_spacing = (screen.window_width()) / (number_of_dots_per_line + 1)

for line in range(1, number_of_lines + 1):
    y = line * v_spacing
    for dot in range(1, number_of_dots_per_line + 1):
        x = dot * h_spacing
        leonardo.penup()
        leonardo.goto(x, y)
        leonardo.pendown()
        leonardo.dot(10, random.choice(rgbs))

print(leonardo.shapesize())

screen.exitonclick()
예제 #22
0
from turtle import Turtle, Screen, Shape
from random import randint
# SCREEN
screen = Screen()
screen.setup(600, 400)  # width, height
screen.tracer(0)  # We'll handle displaying of frames ourselves
# PLAY AREA
play_top = screen.window_height() / 2 - 100  # top of screen minus 100 units
play_bottom = -screen.window_height() / 2 + 100  # 100 from bottom
play_left = -screen.window_width() / 2 + 50  # 50 from left
play_right = screen.window_width() / 2 - 50  # 50 from right
area = Turtle()
area.hideturtle()
area.penup()
area.goto(play_right, play_top)
area.pendown()
area.goto(play_left, play_top)
area.goto(play_left, play_bottom)
area.goto(play_right, play_bottom)
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),
예제 #23
0
from turtle import Turtle,Screen
s = Screen()
s.setup(1000,600)

altura = s.window_height()
ancho = s.window_width()

print("altura:",altura,"\nancho",ancho)
예제 #24
0
from breakout_game import BreakoutGame

screen = Screen()
screen.bgcolor("black")
screen.setup(width=500, height=900)
screen.title("Breakout")

screen.tracer(0)

# SET INITIAL LEVEL
INITIAL_LEVEL = 2

# Screen Dimension Variables
SCREEN_TOP = screen.window_height() / 2
SCREEN_BOTTOM = screen.window_height() / 2 * -1
SCREEN_LEFT = screen.window_width() / 2 * -1
SCREEN_RIGHT = screen.window_width() / 2
SCREEN_DIMS = [(SCREEN_LEFT, SCREEN_RIGHT), (SCREEN_BOTTOM, SCREEN_TOP)]

# Initialise Game
breakout_game = BreakoutGame(initial_level=INITIAL_LEVEL,
                             screen_dims=SCREEN_DIMS)

# The game is watching your moves
screen.listen()
screen.onkey(fun=breakout_game.paddle.move_left, key="Left")
screen.onkey(fun=breakout_game.paddle.move_right, key="Right")

game_is_on = True
while game_is_on:
    # Update the screen
예제 #25
0
def segment_B(turtle):  # right upper
    turtle.setposition(turtle.xcor() + 10 * SCALE, turtle.ycor() + 10 * SCALE)

def segment_C(turtle):  # right lower
    turtle.setposition(turtle.xcor() + 10 * SCALE, turtle.ycor() - 10 * SCALE)

def segment_D(turtle):  # bottom
    turtle.setheading(90)
    turtle.sety(turtle.ycor() - 20 * SCALE)

def segment_E(turtle):  # left lower
    turtle.setposition(turtle.xcor() - 10 * SCALE, turtle.ycor() - 10 * SCALE)

def segment_F(turtle):  # left upper
    turtle.setposition(turtle.xcor() - 10 * SCALE, turtle.ycor() + 10 * SCALE)

def segment_G(turtle):  # center
    turtle.setheading(90)

segments = [segment_G, segment_F, segment_E, segment_D, segment_C, segment_B, segment_A]

digits = Turtle('segment', False)
digits.speed('fastest')
digits.shape('segment')
digits.penup()

digits.setx(SPACING - screen.window_width() / 2)

display_number(digits, "0123456789ABCDEF")
예제 #26
0
from random import randint
import platform
if (platform.system() == "Windows"):
    import winsound

limit = int(input("Lütfen bir hedef skor giriniz"))

screen = Screen()
screen.setup(750, 500)
if (platform.system() == "Windows"):
    winsound.PlaySound('hello.wav', winsound.SND_FILENAME)
screen.tracer(0)

play_top = screen.window_height() / 2 - 100
play_bottom = -screen.window_height() / 2 + 100
play_left = -screen.window_width() / 2 + 50
play_right = screen.window_width() / 2 - 50
area = Turtle()
area.hideturtle()
area.penup()
area.goto(play_right, play_top)
area.pendown()
area.goto(play_left, play_top)
area.goto(play_left, play_bottom)
area.goto(play_right, play_bottom)
area.goto(play_right, play_top)

L = Turtle()
R = Turtle()
L.penup()
R.penup()
예제 #27
0
from turtle import Turtle, Screen

# Screen
screen = Screen()
screen.setup(640, 450)   # width, height
screen.tracer(0)         # We'll handle displaying of frames ourselves
screen.bgcolor("Indigo")

# Area
play_top    = screen.window_height() / 2 - 45   # top of screen minus 45 units
play_bottom = -screen.window_height() / 2 + 45  # 45 from bottom
play_left   = -screen.window_width() / 2 + 64   # 64 from left
play_right  = screen.window_width() / 2 - 64    # 64 from right

border_width = 26
border = border_width / 2

area = Turtle()
area.color("Thistle", "Azure")
area.begin_fill()
area.pensize(border_width)
area.hideturtle()
area.penup()
area.goto(play_right, play_top)
area.pendown()
area.goto(play_left, play_top)
area.goto(play_left, play_bottom)
area.goto(play_right, play_bottom)
area.goto(play_right, play_top)
area.end_fill()
예제 #28
0
    x1 = min(p[0] for p in poly)
    y1 = min(p[1] for p in poly)
    x2 = max(p[0] for p in poly)
    y2 = max(p[1] for p in poly)

    return x1 < x < x2 and y1 < y < y2


def notsafe(turtle):
    position = turtle.position()
    return inside(position, circle) and not inside(position, redcross)

wn = Screen()
wn.bgcolor('lightgreen')
WIDTH = wn.window_width()

layout = Turtle(visible=False)
layout.speed('fastest')
layout.penup()
# turtle.shape("square")

x=15
def north(x):
    turtle.seth(90)
    turtle.forward(x)

def hitnorth():
    north(x)

def south(x):
예제 #29
0
from random import randint, choice
from turtle import Turtle, Screen
import time

screen = Screen()
screen.tracer(0)

width, height = screen.window_width() - 30, screen.window_height(
) - 30  # -30 to account for window borders, etc.

maker1 = Turtle(visible=False)
maker2 = maker1.clone()
maker3 = maker1.clone()
maker4 = maker1.clone()

maker1.goto(50, 50)  # top right
maker2.goto(50, -50)  # bottom right
maker3.goto(-50, -50)  # bottom left
maker4.goto(-50, 50)  # top left

n = randint(1, 360)
m = randint(0, 100)
r = randint(0, 50)
d = choice([True, False])


def out_of_bounds(turtle):
    return not (-width // 2 < turtle.xcor() < width // 2
                and -height // 2 < turtle.ycor() < height // 2)

예제 #30
0
#       []      {}
from turtle import Turtle, Screen
from random import randint

screen = Screen()
screen.setup(width=800, height=400)
user_bet = screen.textinput(
    title="Make your bet",
    prompt="Which turtle will win the race? Enter a color: ")
colors = ["red", "orange", "yellow", "green", "blue", "purple"]

x = -(screen.window_width() / 2) + 20
y = -100
turtles = []
for i in range(len(colors)):
    turtles.append(Turtle(shape="turtle"))
    turtles[i].penup()
    turtles[i].color(colors[i])
    turtles[i].goto(x=x, y=y)
    y += 40

stop = False
while not stop:
    for turtle in turtles:
        speed = randint(0, 20)
        turtle.forward(speed)
        if turtle.xcor() >= (screen.window_width() / 2) - 25:
            stop = True
            if turtle.color()[0] == user_bet:
                print(
                    f"You've won! The {turtle.color()[0]} turtle is the winner!"