Exemple #1
1
def main():
    screen.mode("logo")
    t = Turtle(shape="triangle")
    t.penup(); t.back(280); t.pendown()
    t.pensize(3)
    itree(t, 250, 0.63,
          ["black", "brown", "red", "orange", "violet", "lightblue"])
Exemple #2
0
def main():
    screen.mode("logo")
    t = Turtle(shape="triangle")
    t.penup()
    t.back(280)
    t.pendown()
    t.pensize(3)
    itree(t, 250, 0.63,
          ["black", "brown", "red", "orange", "violet", "lightblue"])
 def ShapeT():
     from turtle import Turtle, Screen, done
     from time import sleep
     Screen().clear()
     t = Turtle()
     t.hideturtle()
     t.left(90)
     t.forward(200)
     t.right(90)
     t.forward(50)
     t.back(100)
     sleep(1)
     test()
     done()
 def ShapeV():
     from turtle import Turtle, Screen, done
     from time import sleep
     Screen().clear()
     t = Turtle()
     t.hideturtle()
     t.up()
     t.back(50)
     t.down()
     t.right(55)
     t.forward(250)
     t.left(115)
     t.forward(250)
     sleep(1)
     test()
     done()
 def ShapeQ():
     from turtle import Turtle, Screen, done
     from time import sleep
     Screen().clear()
     t = Turtle()
     t.hideturtle()
     t.circle(100)
     t.up()
     t.right(-45)
     t.forward(50)
     t.down()
     t.left(90)
     t.back(150)
     sleep(1)
     test()
     done()
 def ShapeX():
     from turtle import Turtle, Screen, done
     from time import sleep
     Screen().clear()
     t = Turtle()
     t.hideturtle()
     t.left(90)
     t.forward(200)
     t.left(90)
     t.forward(50)
     t.back(50)
     t.right(-90)
     t.forward(200)
     t.left(-270)
     t.circle(90, extent=-90)
     sleep(1)
     test()
     done()
Exemple #7
0
def shoot():
    if ready:
        bullet = Turtle(shape='circle')
        bullet.penup()
        bullet.shapesize(ball_size, ball_size, 0)
        bullet.hideturtle()
        bullet.setpos(you.xcor(), you.ycor())
        bullet.color("yellow")
        bullet.showturtle()
        bullet.speed(10)
        if you.shape() == "dog_right.gif":
            bullet.forward(100)
        elif you.shape() == "dog_left.gif":
            bullet.back(100)
        global ball_list
        ball_list.append(bullet)
        if len(ball_list) > ball_count:
            for each in range(0, len(ball_list)):
                ball_list[each].hideturtle()
            ball_list.clear()
from turtle import Turtle, Screen
import colorgram
import random

colors = colorgram.extract("day-18/image.jpg", 30)
new_color = []
for i, color in enumerate(colors):
    new_color.append(tuple(colors[i].rgb))

print(random.choice(new_color))


turtle = Turtle()
screen = Screen()
screen.colormode(255)
screen.setworldcoordinates(0, 0, 500, 500)
turtle.penup()
turtle.speed("fastest")
for i in range(10):
    for j in range(10):
        turtle.dot(20, random.choice(new_color))
        turtle.forward(50)
    turtle.left(90)
    turtle.forward(50)
    turtle.right(90)
    turtle.back(500)
screen.exitonclick()
Exemple #9
0
        t.penup()
        t.goto(cached_x, cached_y)
        t.pendown()


##if __name__ == "__main__":
##    for path in paths:
##        instructions = parse_path(path)
##        for inst in instructions:
##            print(inst)
##            complete_instruction(inst)

# In case the SVG parsing isn't done in time. I am heartbroken
t.penup()
t.left(90)
t.back(300)
t.right(90)
t.pendown()
t.circle(300)
t.penup()
t.left(90)
t.forward(450)
t.left(90)
t.forward(80)
t.pendown()
t.circle(80)
t.penup()
t.right(180)
t.forward(160)
t.pendown()
t.circle(80)
tulip.forward(270)

# tulip.dot(20, random.choice(color_list))
# tulip.right(90)
# for _ in range(12):
#     tulip.forward(50)
#     tulip.dot(20, random.choice(color_list))


tulip.right(90)
tulip.forward(50)
for _ in range(10):
    tulip.dot(20, random.choice(color_list))
    tulip.forward(50)
for _ in range(10):
    tulip.back(500)
    tulip.right(90)
    tulip.forward(50)
    tulip.left(90)
    for _ in range(10):
        tulip.dot(20, random.choice(color_list))
        tulip.forward(50)








              (3, 213, 207), (159, 33, 24), (8, 140, 85), (145, 227, 217),
              (122, 193, 147), (220, 177, 216), (100, 218, 229),
              (117, 171, 192), (79, 135, 178)]


def random_color():
    return random.choice(color_list)


t = Turtle()
s = Screen()
t.hideturtle()
t.penup()
t.speed(0)
t.setpos(-100, -100)
s.title("Spot Painting by Arihant")
s.colormode(255)

for _ in range(10):
    for _ in range(10):  # Prints 1 row of dots
        t.pendown()
        t.dot(20, random_color())
        t.penup()
        t.forward(50)

    t.penup()
    t.back(50)
    t.sety(t.pos()[1] + 50)
    t.right(180)

s.exitonclick()
@author: 小周

"""
'''
=======================
绘制龟兔赛跑现场
=======================
'''
from turtle import Turtle, ontimer, mainloop

rabbit = Turtle()
rabbit.hideturtle()
rabbit.shape('turtle')
rabbit.up()
rabbit.back(300)
rabbit.left(50)
rabbit.showturtle()
rabbit.down()


def rabbitMove():
    if usedTime < 50:  # 奔跑
        rabbit.forward(3)
    elif usedTime < 550:  # 睡觉,位移不变
        rabbit.setheading(0)
        rabbit.forward(0.5)
    else:  # 追赶
        rabbit.setheading(50)
        rabbit.forward(4)
    (46, 122, 86), (72, 43, 35), (145, 178, 148), (13, 99, 71), (233, 175, 164),
    (161, 142, 158), (105, 74, 77), (55, 46, 50), (183, 205, 171), (36, 60, 74),
    (18, 86, 90), (81, 148, 129), (148, 17, 20), (14, 70, 64), (30, 68, 100),
    (107, 127, 153), (174, 94, 97), (176, 192, 209)
]

timmy = Turtle()
screen = Screen()
screen.colormode(255)


timmy.speed(5)

# timmy starting position:
timmy.penup()
timmy.back(200)
timmy.right(90)
timmy.forward(300)
timmy.left(90)
timmy.pendown()

def hirst_painting():
    for i in range(100):
        timmy.dot(20, choice(color_list))

        timmy.penup()
        timmy.forward(50)

        timmy.pendown()
        if timmy.xcor() > 220:
            timmy.left(90)
Exemple #14
0
class Maze:
    def __init__(self,
                 row,
                 col,
                 xCoor=-375,
                 yCoor=350,
                 blockSize=25,
                 hardPoints=True):
        self.row = row
        self.col = col
        self.startXCoor = xCoor
        self.startYCoor = yCoor
        self.blockSize = blockSize
        self.currentlyDrawing = False  # to prevent drawing when currently drawing
        self.currentTurn = 0  # keep track of how many moves

        # initializing for start and end blocks Coordinates (usefull for randomly placed blocks)
        self.startBlockCoors = list()
        self.endBlockCoors = list()

        # initializing for Current x and y in array, very useful for walking through the maze
        self.currentArrayLocation = list()

        #Make a X by Y 2d array filled with 0's
        self.blocks = [[0 for x in range(self.col)] for y in range(self.row)]

        # Fill all blocks as closed
        for i in range(self.row):
            for j in range(self.col):
                self.blocks[i][j] = Block('closed', blockSize)

        # Setting up Turtle for drawing
        self.t = Turtle()
        self.t.screen.bgcolor('peach puff')
        self.t.color("dark slate gray")
        self.t.shape("turtle")
        self.t.speed(0)

        # Turn off animations to make it go fast
        self.t.screen.tracer(0)

        # move starting drawing point to coordinates
        self.t.up()
        self.t.goto(xCoor, yCoor)
        self.t.down()

        # make the maze pathway itself
        self.makePaths(hardPoints)
        # draw what is inside the 2d array
        self.drawMaze()

        # update the screen after making changes (I disabled automatically updating the screen to make it draw instantly)
        self.t.screen.update()

        # Turns back on animation and puts turtle at starting block
        self.setUpForSolving()

    # Draws a block and moves the cursor to bottom left hand corner of new block, facing east of new
    def drawBlock(self, block, MovedOn=None, stopColoring=False):
        self.currentlyDrawing = True
        # For drawing blocks normally
        if MovedOn is None:
            # Draws a block if it is closed, start, or end
            if block.state in ["closed", 'start', 'end', 'wall']:
                self.t.color(block.color)
                self.t.begin_fill()
                # Draw the square
                for _ in range(4):
                    self.t.fd(block.size)
                    self.t.right(90)
                self.t.end_fill()

            # Move to bottom left corner of block just made
            self.t.up()
            self.t.right(90)
            self.t.fd(block.size)
            self.t.down()
            self.t.left(90)
        else:  # For drawing blocks when walking through the maze
            if block.state in ['closed', 'wall']:
                raise ValueError("Can't move on a Wall or closed Block!")
            else:
                self.currentTurn += 1

                block.turnMovedOn = self.currentTurn

                # set color of block
                if (block.visited <= 1):
                    self.t.color('yellow')
                elif (block.visited == 2):
                    self.t.color('goldenrod')
                elif (block.visited == 3):
                    self.t.color('chocolate')
                elif (block.visited == 4):
                    self.t.color('saddle brown')
                elif (block.visited == 5):
                    self.t.color('maroon')
                else:
                    self.t.color('black')

                # Draw the square
                if (stopColoring):
                    self.t.up()
                else:
                    self.t.down()
                    self.t.begin_fill()

                for _ in range(4):
                    self.t.fd(block.size)
                    self.t.right(90)

                if (not stopColoring):
                    self.t.end_fill()

                # move to top right left of block just made
                self.t.up()

                self.t.fd(block.size)
        self.currentlyDrawing = False  # set it back to False

    # Calls Draw for each block
    def drawMaze(self):
        # Go through list and draw blocks
        for i in range(self.row):
            for j in range(self.col):
                self.drawBlock(self.blocks[i][j])

            # Move to the next Column
            self.t.up()
            self.t.fd(self.blocks[i][j].size)
            self.t.left(90)
            self.t.fd(self.blocks[i][j].size * (j + 1))
            self.t.right(90)
            self.t.down()

    # Maze Code based on:
    #https://github.com/Malmactor/maze-solver/blob/master/src/generator.py
    #Which uses Prim's method:
    #https://en.wikipedia.org/wiki/Maze_generation_algorithm

    def makePaths(self, hardPoints=True):
        maze_r = self.row
        maze_c = self.col

        # Set edges as wall
        for i in range(self.row):
            for j in range(self.col):
                if (i == 0 or j == 0 or i == (self.row - 1)
                        or j == (self.col - 1)):
                    self.blocks[i][j].state = 'wall'
                    self.blocks[i][j].color = 'black'

        # Puts starting point in the top left corner
        if hardPoints:
            # For starting in the top left corner
            start_x = 0
            start_y = 1
        else:
            # for starting in random location
            start_x = np.random.random_integers(maze_r) - 1
            start_y = np.random.random_integers(maze_c) - 1

        # Store coordinates of starting block
        self.startBlockCoors.append(start_x)
        self.startBlockCoors.append(start_y)

        # declare it a start block and make it green
        self.blocks[start_x][start_y].state = 'start'
        self.blocks[start_x][start_y].color = 'green'
        start = Point(start_x, start_y)

        # iterate through direct neighbors of node
        frontier = list()
        for x in range(-1, 2):
            for y in range(-1, 2):
                if x * y == 0 and x + y != 0:
                    if start.r + x >= 0 and start.r + x < maze_r and start.c + y >= 0 and start.c + y < maze_c:
                        frontier.append(Point(start.r + x, start.c + y, start))

        last = None  # Initializing last for later

        # Go through current neighbors
        while frontier:
            # pick current neighbor at random
            current = frontier.pop(
                np.random.random_integers(len(frontier)) - 1)
            opposite = current.opposite()

            # if both current neighbor and its opposite are walls
            if opposite.r >= 0 and opposite.r < maze_r and opposite.c >= 0 and opposite.c < maze_c:
                if self.blocks[current.r][
                        current.c].state == 'closed' and self.blocks[
                            opposite.r][opposite.c].state == 'closed':
                    # open path between the nodes
                    self.blocks[current.r][current.c].state = 'open'
                    self.blocks[opposite.r][opposite.c].state = 'open'

                    # store last node in order to mark it later
                    last = opposite
                    # iterate through direct neighbors of current node, same as earlier
                    for x in range(-1, 2):
                        for y in range(-1, 2):
                            if x * y == 0 and x + y != 0:
                                if opposite.r + x >= 0 and opposite.r + x < maze_r and opposite.c + y >= 0 and opposite.c + y < maze_c:
                                    frontier.append(
                                        Point(opposite.r + x, opposite.c + y,
                                              opposite))

        # if maze is finished, there will be no more neighbors
        if last:
            if hardPoints:
                # setting exit to be on the bottom right hand corner
                self.blocks[self.row - 1][self.col - 3].state = 'end'
                self.blocks[self.row - 1][self.col - 3].color = 'red'

                # set end block coordinates
                self.endBlockCoors.append(self.row - 1)
                self.endBlockCoors.append(self.col - 3)
            else:
                # If you want the exit to move around
                self.blocks[last.r][last.c].state = 'end'
                self.blocks[last.r][last.c].color = 'red'
                self.endBlockCoors.append(last.r)
                self.endBlockCoors.append(last.c)

    def setUpForSolving(self):
        # This function goes to the starting block and sets it up for someone to start finding a way to the end

        self.t.up()
        # To go back to starting block, move to starting coordinate and the away by how many blocks it started by
        x = self.startXCoor + (self.blockSize * self.startBlockCoors[0])
        y = self.startYCoor - (self.blockSize * self.startBlockCoors[1])

        # Adding visiting logic to starting block for later
        self.blocks[self.startBlockCoors[0]][
            self.startBlockCoors[1]].visited += 2

        # go to that location
        self.t.goto(x, y)
        self.t.fd(self.blockSize)
        self.t.down()

        # Gets current x and y coordinates of the block in the array
        self.currentArrayLocation.append(self.startBlockCoors[0])
        self.currentArrayLocation.append(self.startBlockCoors[1])

        # change turtle color
        self.t.color("yellow")
        self.t.shape("turtle")
        self.t.speed(0.5)
        # Turn animation back on
        self.t.screen.tracer(1)

    # This Function moves the turtle 1 block to the right if it is not a wall
    # Return True if it moved, False if it didn't
    def moveRight(self):
        nextBlock = self.blocks[self.currentArrayLocation[0] +
                                1][self.currentArrayLocation[1]]
        #currentArrayLocation[0] == x, + 1 for the block to the right of current block
        #self.currentArrayLocation[1] == y

        #Won't move past a wall
        if nextBlock.state == 'open' and self.currentlyDrawing is False:
            self.currentArrayLocation[0] += 1  # update current location
            nextBlock.visited += 1
            # draw the block
            # (Make sure you are on the top left corner of the block you want to draw)
            self.drawBlock(nextBlock, True)

    def moveLeft(self):
        nextBlock = self.blocks[self.currentArrayLocation[0] -
                                1][self.currentArrayLocation[1]]

        if nextBlock.state == 'open' and self.currentlyDrawing is False:
            self.currentArrayLocation[0] -= 1  # update current location
            nextBlock.visited += 1
            # Make sure you are on the top left corner of the block you want to draw)
            self.t.up()
            self.t.back(self.blockSize * 2)
            self.t.down()
            self.drawBlock(nextBlock, True)

    def moveDown(self):
        nextBlock = self.blocks[self.currentArrayLocation[0]][
            self.currentArrayLocation[1] + 1]
        if nextBlock.state == 'open' and self.currentlyDrawing is False:
            self.currentArrayLocation[1] += 1  # update current location
            nextBlock.visited += 1
            # Make sure you are on the top left corner of the block you want to draw)
            self.t.up()
            self.t.back(self.blockSize)
            self.t.right(90)
            self.t.fd(self.blockSize)
            self.t.left(90)
            self.t.down()
            self.drawBlock(nextBlock, True)

    def moveUp(self):
        nextBlock = self.blocks[self.currentArrayLocation[0]][
            self.currentArrayLocation[1] - 1]
        if nextBlock.state == 'open' and self.currentlyDrawing is False:
            self.currentArrayLocation[1] -= 1  # update current location
            nextBlock.visited += 1
            # Make sure you are on the top left corner of the block you want to draw)
            self.t.up()
            self.t.back(self.blockSize)
            self.t.left(90)
            self.t.fd(self.blockSize)
            self.t.right(90)
            self.t.down()
            self.drawBlock(nextBlock, True)

    def moveDirection(self, direction=""):
        if (direction == 'right'):
            self.moveRight()
        elif (direction == "left"):
            self.moveLeft()
        elif (direction == "up"):
            self.moveUp()
        elif (direction == "down"):
            self.moveDown()

    # returns the type of the block that is next to the current block, returns block instead if parameter is True
    def checkSpace(self, direction="", returnBlock=False):
        if (direction == "right"):
            if (returnBlock is False):
                return self.blocks[self.currentArrayLocation[0] + 1][
                    self.currentArrayLocation[
                        1]].state  # ["closed", 'start', 'end', 'wall','open']:
            else:
                return self.blocks[self.currentArrayLocation[0] +
                                   1][self.currentArrayLocation[1]]
        elif (direction == "left"):

            if (returnBlock is False):
                return self.blocks[self.currentArrayLocation[0] -
                                   1][self.currentArrayLocation[1]].state
            else:
                return self.blocks[self.currentArrayLocation[0] -
                                   1][self.currentArrayLocation[1]]
        elif (direction == "up"):
            if (returnBlock is False):
                return self.blocks[self.currentArrayLocation[0]][
                    self.currentArrayLocation[1] - 1].state
            else:
                return self.blocks[self.currentArrayLocation[0]][
                    self.currentArrayLocation[1] - 1]
        elif (direction == "down"):
            if (returnBlock is False):
                return self.blocks[self.currentArrayLocation[0]][
                    self.currentArrayLocation[1] + 1].state
            else:
                return self.blocks[self.currentArrayLocation[0]][
                    self.currentArrayLocation[1] + 1]
        else:
            return "invalid"
        """ 
Exemple #15
0
from turtle import Turtle, Screen

rabbit = Turtle()


rabbit.shape("turtle")
rabbit.color(0.3, 0.4, 0.5)


rabbit.penup()
rabbit.back(500)

for i in range(96):
    if i & 1:
        rabbit.pendown()
    else:
        rabbit.penup()
    rabbit.forward(10)

rabbit.shape("classic")
rabbit.stamp()


rabbit.shape("turtle")
rabbit.hideturtle()

screen = Screen()
screen.exitonclick()
print(f'{espacos} Ok {nome} vamos jogar um pouco! {espacos}')
print(f'{espacos} Você vai movimentar a tartaruga! {espacos}')

jogar = True
ft = False
de = False
while jogar == True:
    frente_tras = input(
        'Você quer ir com a tartaruga para frente ou para trás? (Responda "f" para frente e "t" para trás) ')
    if frente_tras == 'f' or frente_tras == 'frente':
        pf = int(input('Quantos px você quer que ela ande?: '))
        tartaruga.forward(pf)

    else:
        pt = int(input('Quantos px você quer que ela ande?: '))
        tartaruga.back(pt)

    direita_esquerda = input(
        'Você quer ir com a tartaruga para direira ou para esquerda? (Responda "d" para direita e "e" para esuqerda)')
    if direita_esquerda in 'd' or 'direita':
        graus = int(input('Quantos graus você quer que ela vire?: '))
        tartaruga.right(graus)
        p = int(input('Quantos px você quer que ela ande?: '))
        tartaruga.forward(p)

    else:
        graus = int(input('Quantos graus você quer que ela vire?: '))
        tartaruga.left(graus)
        p = int(input('Quantos px você quer que ela ande?: '))
        tartaruga.forward(p)
Exemple #17
0
from turtle import Turtle, Screen, mainloop, TurtleScreen

michael = Turtle()
screen = Screen()


def print_something():
    print("PRINT")


def forward():
    michael.forward(10)


screen.onkeyrelease(forward, "w")
screen.onkeyrelease(lambda: michael.back(10), "s")
screen.onkeyrelease(lambda: michael.right(2), "d")
screen.onkeyrelease(lambda: michael.left(2), "a")


def clear():
    michael.clear()
    michael.penup()
    # michael.goto(0, 0)
    # michael.setheading(0)
    michael.home()
    michael.pendown()


screen.onkeyrelease(clear, "c")