Open in app

Sign in

Write

Sign in

Projeto Guiado— Corrida de Tartarugas

Luiza Lissandra
Reflexão Computacional
Published in
12 min readJun 29, 2019

--

Projeto da corrida de Tartaruga.

Sobre este projeto

Este projeto foi elaborado pela Code Club e esta seção é apenas uma tradução do tutorial do projeto Turtle Race com algumas adaptações. A versão original deste tutorial pode ser encontrada neste link.

Pré-requisitos

Desenvolvimento do Projeto

O desenvolvimento do projeto foi dividido em etapas, são elas:

  1. Criação da Tartaruga para desenhar a pista de corrida;
  2. Desenhar a pista de corrida;
  3. Criação das Tartarugas de corrida (coloridas);
  4. Processo da corrida de tartarugas;
  5. Exibição da tartaruga vencedora.

Tartaruga para pista de Corrida

Antes de tudo, precisamos importar o módulo Turtle, o qual é feito com o comando import seguido do nome do módulo, Turtle no caso.

# Importando o módulo Turtle
import turtle

Após a importação, já podemos criar a Tartaruga que irá desenhar a nossa pista de corrida. Ela é criada da seguinte forma:

# Importando o módulo Turtle
import turtle# Criando Tartaruga que desenhará a pista de corrida
tartaruga_pista = turtle.Turtle()

Lembrando que todos os comandos possíveis de movimento, controle da caneta, etc., pode ser visualizado na documentação auxiliar do módulo Turtle.

Pista de Corrida

A nossa pista de corrida deve ter a seguinte aparência:

Aparência da pista de corrida.

Veremos por partes como podemos construir essa pista de corrida, vamos buscar entender todos os passos envolvidos.

Desenhar uma linha

Para desenhar uma linha, podemos utilizar o método forward (“pra frente”) indicando a distância em pixels como argumento.

# APENAS UM EXEMPLO, NÃO DEVE FAZER PARTE DO CÓDIGO DO PROJETO# Importando módulo
import turtle# Criando Tartaruga
tartaruga = turtle.Turtle()# Escrevendo linha
tartaruga.forward(100)

Fragmentar a linha

Para fragmentar a linha, precisamos ativar e desativar a caneta durante o movimento da tartaruga.

# Importando módulo
import turtle# Criando Tartaruga
tartaruga = turtle.Turtle()# Tartaruga apontando pra baixo
tartaruga.right(90)# Faça 15 vezes
for step in range(0, 15):
    # Ativando e desativando a caneta
    if step % 2 == 0:
        tartaruga.penup()
    else:
        tartaruga.pendown()
    # Anda 10 pixels pra frente
    tartaruga.forward(10)

Diversas linhas

Precisamos criar diversas linhas. A princípio, vamos criar essas linhas sem nos preocupar com o pontilhamento.

# Importando módulo
import turtle# Criando Tartaruga
tartaruga = turtle.Turtle()# Posição inicial para a criação das linhas tupla(x, y)
posicao_inicial = (-300, 200)# Espaçamento
espacamento = 30# Desativando a caneta antes de qualquer movimento
tartaruga.penup()# Movendo a tartaruga para a posição inicial e apontando para baixo
tartaruga.right(90)
tartaruga.setpos(posicao_inicial[0], posicao_inicial[1])# Faça 20 vezes, para criar 20 linhas
for step in range(0,20):
    # Ativando a caneta
    tartaruga.pendown()
    # Escrevendo a linha
    tartaruga.forward(400)
    # Desativando a caneta
    tartaruga.penup()
    # Indo para a próxima posição
    novo_x = tartaruga.pos()[0] + espacamento
    novo_y = posicao_inicial[1]
    tartaruga.setpos(novo_x, novo_y)

Para pontilharmos a linha, basta substituirmos a parte de código que escreve uma linha reta:

tartaruga.forward(400)

Pela forma como fizemos lá em cima para criar a linha pontilhada, fazendo os devidos ajustes para criarmos uma linha do mesmo tamanho.

# Criando linha pontilhada de tamanho 400
for step in range(0, 40):
    # Ativando e desativando a caneta
    if step % 2 == 0:
        tartaruga.penup()
    else:
        tartaruga.pendown()
    # Anda 10 pixels pra frente
    tartaruga.forward(10)

E o nosso código ficaria da seguinte forma:

# Importando módulo
import turtle# Criando Tartaruga
tartaruga = turtle.Turtle()# Posição inicial para a criação das linhas tupla(x, y)
posicao_inicial = (-300, 200)# Espaçamento
espacamento = 30# Desativando a caneta antes de qualquer movimento
tartaruga.penup()# Movendo a tartaruga para a posição inicial e apontando para baixo
tartaruga.right(90)
tartaruga.setpos(posicao_inicial[0], posicao_inicial[1])# Faça 20 vezes, para criar 20 linhas
for step in range(0,20):
    # Ativando a caneta
    tartaruga.pendown()    # Criando linha pontilhada de tamanho 400
    for step in range(0, 40):
        # Ativando e desativando a caneta
        if step % 2 == 0:
            tartaruga.penup()
        else:
            tartaruga.pendown()
        # Anda 10 pixels pra frente
        tartaruga.forward(10)    # Desativando a caneta
    tartaruga.penup()
    # Indo para a próxima posição
    novo_x = tartaruga.pos()[0] + espacamento
    novo_y = posicao_inicial[1]
    tartaruga.setpos(novo_x, novo_y)

Numeração nas linhas

Basta chamarmos o método de escrita de texto, write(<texto>), para escrevemos o número de cada linha antes de cada linha ser desenhada.

# Importando módulo
import turtle# Criando Tartaruga
tartaruga = turtle.Turtle()# Posição inicial para a criação das linhas tupla(x, y)
posicao_inicial = (-300, 200)# Espaçamento
espacamento = 30# Desativando a caneta antes de qualquer movimento
tartaruga.penup()# Movendo a tartaruga para a posição inicial e apontando para baixo
tartaruga.right(90)
tartaruga.setpos(posicao_inicial[0], posicao_inicial[1])# Faça 20 vezes, para criar 20 linhas
for step in range(0,20):    # Escrevendo número da linha
    tartaruga.write(step+1) # step+1 pois começa em 0    # Ativando a caneta
    tartaruga.pendown()# Criando linha pontilhada de tamanho 400
    for step in range(0, 40):
        # Ativando e desativando a caneta
        if step % 2 == 0:
            tartaruga.penup()
        else:
            tartaruga.pendown()
        # Anda 10 pixels pra frente
        tartaruga.forward(10)# Desativando a caneta
    tartaruga.penup()
    # Indo para a próxima posição
    novo_x = tartaruga.pos()[0] + espacamento
    novo_y = posicao_inicial[1]
    tartaruga.setpos(novo_x, novo_y)

Tartarugas corredoras

Vamos criar 5 tartarugas corredoras, no formato de tartarugas, com cores diferentes e também daremos nomes para cada uma delas.

Antes de criarmos, vamos definir uma lista de nomes e outra de cores para cada tartaruga:

# Dados das tartarugas
nomes = ["Lucas", "Pedro", "Bruno", "Carla", "Tiago"]
cores = ["red", "blue", "yellow", "green", "purple"]

Durante a criação, também precisamos mover as tartarugas até para a posição de largada.

# Dados das tartarugas
nomes = ["Lucas", "Pedro", "Bruno", "Carla", "Tiago"]
cores = ["red", "blue", "yellow", "green", "purple"]# Dicionário que armazenará as tartarugas
tartarugas = dict()# Posição de largada
posicao_largada = (-330, 150)
espacamento = 50# Criando cada Tartaruga
for nome, cor in zip(nomes, cores):
    tartarugas[nome] = turtle.Turtle()
    tartarugas[nome].shape("turtle")
    tartarugas[nome].color(cor)    # Movendo para a posição de larga
    pos_x = posicao_largada[0]
    pos_y = posicao_largada[1] - (espacamento * len(tartarugas)) 
    tartarugas[nome].penup()
    tartarugas[nome].setpos(pos_x, pos_y)
    tartarugas[nome].pendown()

Com a adição da parte da criação, nosso código fica da seguinte forma:

# Importando módulo
import turtle# Criando Tartaruga
tartaruga = turtle.Turtle()# Posição inicial para a criação das linhas tupla(x, y)
posicao_inicial = (-300, 200)# Espaçamento
espacamento = 30# Desativando a caneta antes de qualquer movimento
tartaruga.penup()# Movendo a tartaruga para a posição inicial e apontando para baixo
tartaruga.right(90)
tartaruga.setpos(posicao_inicial[0], posicao_inicial[1])# Faça 20 vezes, para criar 20 linhas
for step in range(0,20):# Escrevendo número da linha
    tartaruga.write(step+1) # step+1 pois começa em 0# Ativando a caneta
    tartaruga.pendown()# Criando linha pontilhada de tamanho 400
    for step in range(0, 40):
        # Ativando e desativando a caneta
        if step % 2 == 0:
            tartaruga.penup()
        else:
            tartaruga.pendown()
        # Anda 10 pixels pra frente
        tartaruga.forward(10)# Desativando a caneta
    tartaruga.penup()
    # Indo para a próxima posição
    novo_x = tartaruga.pos()[0] + espacamento
    novo_y = posicao_inicial[1]
    tartaruga.setpos(novo_x, novo_y)# Dados das tartarugas
nomes = ["Lucas", "Pedro", "Bruno", "Carla", "Tiago"]
cores = ["red", "blue", "yellow", "green", "purple"]# Dicionário que armazenará as tartarugas
tartarugas = dict()# Posição de largada
posicao_largada = (-330, 150)
espacamento = 50# Criando cada Tartaruga
for nome, cor in zip(nomes, cores):
    tartarugas[nome] = turtle.Turtle()
    tartarugas[nome].shape("turtle")
    tartarugas[nome].color(cor)    # Movendo para a posição de larga
    pos_x = posicao_largada[0]
    pos_y = posicao_largada[1] - (espacamento * len(tartarugas)) 
    tartarugas[nome].penup()
    tartarugas[nome].setpos(pos_x, pos_y)
    tartarugas[nome].pendown()

Vamos adicionar uma animação para cada tartaruga dar uma volta completa assim que chegar na posição de largada.

# Passos para dar uma volta completa
passos = 8
for passo in range(0, passos):
    tartarugas[nome].right(360/passos)

E o nosso código fica assim:

# Importando módulo
import turtle# Criando Tartaruga
tartaruga = turtle.Turtle()# Posição inicial para a criação das linhas tupla(x, y)
posicao_inicial = (-300, 200)# Espaçamento
espacamento = 30# Desativando a caneta antes de qualquer movimento
tartaruga.penup()# Movendo a tartaruga para a posição inicial e apontando para baixo
tartaruga.right(90)
tartaruga.setpos(posicao_inicial[0], posicao_inicial[1])# Faça 20 vezes, para criar 20 linhas
for step in range(0,20):# Escrevendo número da linha
    tartaruga.write(step+1) # step+1 pois começa em 0# Ativando a caneta
    tartaruga.pendown()# Criando linha pontilhada de tamanho 400
    for step in range(0, 40):
        # Ativando e desativando a caneta
        if step % 2 == 0:
            tartaruga.penup()
        else:
            tartaruga.pendown()
        # Anda 10 pixels pra frente
        tartaruga.forward(10)# Desativando a caneta
    tartaruga.penup()
    # Indo para a próxima posição
    novo_x = tartaruga.pos()[0] + espacamento
    novo_y = posicao_inicial[1]
    tartaruga.setpos(novo_x, novo_y)# Dados das tartarugas
nomes = ["Lucas", "Pedro", "Bruno", "Carla", "Tiago"]
cores = ["red", "blue", "yellow", "green", "purple"]# Dicionário que armazenará as tartarugas
tartarugas = dict()# Posição de largada
posicao_largada = (-330, 150)
espacamento = 50# Criando cada Tartaruga
for nome, cor in zip(nomes, cores):
    tartarugas[nome] = turtle.Turtle()
    tartarugas[nome].shape("turtle")
    tartarugas[nome].color(cor)    # Movendo para a posição de larga
    pos_x = posicao_largada[0]
    pos_y = posicao_largada[1] - (espacamento * len(tartarugas)) 
    tartarugas[nome].penup()
    tartarugas[nome].setpos(pos_x, pos_y)    # Passos para dar uma volta completa
    passos = 8
    for passo in range(0, passos):
         tartarugas[nome].right(360/passos)
    
    tartarugas[nome].pendown()

Processo da corrida de tartarugas

Nossas tartarugas precisam correr uma quantidade uma distância variada a cada “segundo” (iteração na verdade). Utilizaremos o módulo random para gerar um inteiro aleatório dado um intervalo — função randint().

Para gerarmos um número aleatório, precisamos importar o módulo e executar a função randint() indicando os intervalos. Por exemplo:

import random# Gerando um número entre 1 e 5
random.rand_int(1, 5)

Agora que já sabemos como gerar essa distância aleatória, vamos ver como fica o código para fazer as tartarugas correrem:

import random# (...) -> pulando código# Repita sempre
while True:
    # Nomes é uma lista com todos os nomes das tartarugas
    for nome in nomes:
        # Obtendo a distância
        distancia = random.randint(1, 5)
        # Fazendo a tartaruga andar a distância
        tartarugas[nome].forward(distancia)

O código acima fará cada tartaruga correr uma distância aleatória (entre 1 e 5) a cada iteração. No entanto, esse código fará as tartarugas correrem infinitamente devido a condição do while.

Precisamos criar uma condição para interromper a corrida quando uma das tartarugas ultrapassar a linha de chegada. Mas quando será isso?

A primeira linha pontilhada foi criada na posicao_inicial = (-300, 200). Fizemos 20 linhas, cada uma contendo espacamento = 30. Então, fazendo nossos cálculos…

Fazendo nossos cálculos…

… a posição da última linha está localizada na posição (300, 200). Se tivemos 20 linhas espaçadas por 30 pixels, então distância da posição x da última linha é o produto destes valores (20 x 30 = 600). A posição x final é igual a posição inicial (-300) + a distância (600). Ou seja, a posição x final é igual a 300.

Então, a uma tartaruga vencerá a corrida quando sua posição x for superior a 300 no nosso sistema de coordenadas. Então, vamos colocar a verificação da seguinte forma:

import random# (...) -> pulando código# Variável pra armazenar o nome da tartaruga vencedora
vencedora = ""# Enquanto não houver vencedora
while not vencedora:
    # Nomes é uma lista com todos os nomes das tartarugas
    for nome in nomes:
        # Obtendo a distância
        distancia = random.randint(1, 5)
        # Fazendo a tartaruga andar a distância
        tartarugas[nome].forward(distancia)
        
        # Verificando se essa tartaruga venceu
        if tartarugas[nome].pos()[0] > 300:
            vencedora = nome
            break

O nosso código completo com essa nova parte fica da seguinte maneira:

# Importando módulos
import turtle
import random# Criando Tartaruga
tartaruga = turtle.Turtle()# Posição inicial para a criação das linhas tupla(x, y)
posicao_inicial = (-300, 200)# Espaçamento
espacamento = 30# Desativando a caneta antes de qualquer movimento
tartaruga.penup()# Movendo a tartaruga para a posição inicial e apontando para baixo
tartaruga.right(90)
tartaruga.setpos(posicao_inicial[0], posicao_inicial[1])# Faça 20 vezes, para criar 20 linhas
for step in range(0,20):# Escrevendo número da linha
    tartaruga.write(step+1) # step+1 pois começa em 0# Ativando a caneta
    tartaruga.pendown()# Criando linha pontilhada de tamanho 400
    for step in range(0, 40):
        # Ativando e desativando a caneta
        if step % 2 == 0:
            tartaruga.penup()
        else:
            tartaruga.pendown()
        # Anda 10 pixels pra frente
        tartaruga.forward(10)# Desativando a caneta
    tartaruga.penup()
    # Indo para a próxima posição
    novo_x = tartaruga.pos()[0] + espacamento
    novo_y = posicao_inicial[1]
    tartaruga.setpos(novo_x, novo_y)# Dados das tartarugas
nomes = ["Lucas", "Pedro", "Bruno", "Carla", "Tiago"]
cores = ["red", "blue", "yellow", "green", "purple"]# Dicionário que armazenará as tartarugas
tartarugas = dict()# Posição de largada
posicao_largada = (-330, 150)
espacamento = 50# Criando cada Tartaruga
for nome, cor in zip(nomes, cores):
    tartarugas[nome] = turtle.Turtle()
    tartarugas[nome].shape("turtle")
    tartarugas[nome].color(cor)# Movendo para a posição de larga
    pos_x = posicao_largada[0]
    pos_y = posicao_largada[1] - (espacamento * len(tartarugas)) 
    tartarugas[nome].penup()
    tartarugas[nome].setpos(pos_x, pos_y)# Passos para dar uma volta completa
    passos = 8
    for passo in range(0, passos):
         tartarugas[nome].right(360/passos)
    
    tartarugas[nome].pendown()# Variável pra armazenar o nome da tartaruga vencedora
vencedora = ""# Enquanto não houver vencedora
while not vencedora:
    # Nomes é uma lista com todos os nomes das tartarugas
    for nome in nomes:
        # Obtendo a distância
        distancia = random.randint(1, 5)
        # Fazendo a tartaruga andar a distância
        tartarugas[nome].forward(distancia)
        
        # Verificando se essa tartaruga venceu
        if tartarugas[nome].pos()[0] > 300:
            vencedora = nome
            break

Exibição da tartaruga vencedora

Algumas vezes, as tartarugas chegarão na linha de chegada tão próximas que vai ser difícil visualizar qual delas foi a vencedora. Então, vamos exibir essa informação no canvas.

O código de exibição pode ser simplesmente levando a tartaruga vencedora para uma área de destaque e escrevendo que ela é a vencedora. Por exemplo:

# "tartaruga" é a nossa tartaruga que desenhou a pista de corrida
tartaruga.penup()
tartaruga.setposition(0, -300)mensagem = "A tartaruga vencedora foi: {}".format(vencedora)# Fonte com Nome, tamanho e forma
fonte = ("Comic Sans", 20, "bold")  # Texto, move a tartaruga para o final, alinhamento e e fonte 
tartaruga.write(mensagem, True, "center", fonte)# Movendo a tartaruga vencedora
tartarugas[vencedora].penup()
tartarugas[vencedora].setposition(0, -330)
# Comemorando
while True:
    tartarugas[vencedora].right(10)

Nosso código completo ficou da seguinte forma:

# Importando módulos
import turtle
import random# Criando Tartaruga
tartaruga = turtle.Turtle()# Posição inicial para a criação das linhas tupla(x, y)
posicao_inicial = (-300, 200)# Espaçamento
espacamento = 30# Desativando a caneta antes de qualquer movimento
tartaruga.penup()# Movendo a tartaruga para a posição inicial e apontando para baixo
tartaruga.right(90)
tartaruga.setpos(posicao_inicial[0], posicao_inicial[1])# Faça 20 vezes, para criar 20 linhas
for step in range(0,20):# Escrevendo número da linha
    tartaruga.write(step+1) # step+1 pois começa em 0# Ativando a caneta
    tartaruga.pendown()# Criando linha pontilhada de tamanho 400
    for step in range(0, 40):
        # Ativando e desativando a caneta
        if step % 2 == 0:
            tartaruga.penup()
        else:
            tartaruga.pendown()
        # Anda 10 pixels pra frente
        tartaruga.forward(10)# Desativando a caneta
    tartaruga.penup()
    # Indo para a próxima posição
    novo_x = tartaruga.pos()[0] + espacamento
    novo_y = posicao_inicial[1]
    tartaruga.setpos(novo_x, novo_y)# Dados das tartarugas
nomes = ["Lucas", "Pedro", "Bruno", "Carla", "Tiago"]
cores = ["red", "blue", "yellow", "green", "purple"]# Dicionário que armazenará as tartarugas
tartarugas = dict()# Posição de largada
posicao_largada = (-330, 150)
espacamento = 50# Criando cada Tartaruga
for nome, cor in zip(nomes, cores):
    tartarugas[nome] = turtle.Turtle()
    tartarugas[nome].shape("turtle")
    tartarugas[nome].color(cor)# Movendo para a posição de larga
    pos_x = posicao_largada[0]
    pos_y = posicao_largada[1] - (espacamento * len(tartarugas)) 
    tartarugas[nome].penup()
    tartarugas[nome].setpos(pos_x, pos_y)# Passos para dar uma volta completa
    passos = 8
    for passo in range(0, passos):
         tartarugas[nome].right(360/passos)
    
    tartarugas[nome].pendown()# Variável pra armazenar o nome da tartaruga vencedora
vencedora = ""# Enquanto não houver vencedora
while not vencedora:
    # Nomes é uma lista com todos os nomes das tartarugas
    for nome in nomes:
        # Obtendo a distância
        distancia = random.randint(1, 5)
        # Fazendo a tartaruga andar a distância
        tartarugas[nome].forward(distancia)
        
        # Verificando se essa tartaruga venceu
        if tartarugas[nome].pos()[0] > 300:
            vencedora = nome
            break# "tartaruga" é a nossa tartaruga que desenhou a pista de corrida
tartaruga.penup()
tartaruga.setposition(0, -300)mensagem = "A tartaruga vencedora foi: {}".format(vencedora)# Fonte com Nome, tamanho e forma
fonte = ("Comic Sans", 20, "bold")# Texto, move a tartaruga para o final, alinhamento e e fonte 
tartaruga.write(mensagem, True, "center", fonte)# Movendo a tartaruga vencedora
tartarugas[vencedora].penup()
tartarugas[vencedora].setposition(0, -330)
# Comemorando
while True:
    tartarugas[vencedora].right(10)
Imagem final da nossa corrida de Tartarugas!

Pra encerrar…

Esperamos que tenha gostado deste projeto guiado e esperamos que você faça melhorias no projeto e, se possível, nos envie essas melhorias.

Desafio

Após estudar a seção sobre funções, tente reescrever o código deste projeto usando funções, com o fim de modularizar e simplificar o código do projeto.

Python
Turtle
Project
Projeto

--

--

Luiza Lissandra
Reflexão Computacional

Written by Luiza Lissandra

30 Followers

Engenharia Eletrônica e de Computação — UFRJ

Help

Status

About

Careers

Press

Blog

Privacy

Terms

Text to speech

Teams