I can not get the right speed for bad and good players in this Minigame off YouTube called 'Falling Skies": GitHub Gist which uses the Python turtle module. How do I fix this? (I got stuck on Part 6 of the Minigame tutorial.)
import turtle # Our module's
import random
# Screen
ms = turtle.Screen()
ms.title("Falling Piece's mini_game by Rafa94")
ms.bgcolor("purple")
ms.setup(width=800, height=600)
ms.tracer(0)
#player
player = turtle.Turtle()
player.speed(0)
player.shape("turtle")
player.color("blue")
player.penup()
player.goto(0, -250) # y is postive in the up direction y is negative in the down direction
player.direction = "stop"
# create a list of good players # good represents good_player
goods =[]#Empty list
#Addgood players
for _ in range(20): # we are making a set of 20 players
good = turtle.Turtle() # we want the other player basically across from each other thats we copyed the code one on -y and one on +y (first player in the bottom, second player on top of Screen)
good.speed(0)
good.shape("circle")
good.color("red")
good.penup()
good.goto(0, 250) # y is postive in the up direction y is negative in the down direction
good.speed = random.randint(5,8)
goods.append(good)
# create a list of bad players # bad represents bad_players
bads = [] # Empty list
# Addbad players
for _ in range(20): # we are making a set of 20 players
bad = turtle.Turtle() # we want the other player basically across from each other thats we copyed the code one on -y and one on +y (first player in the bottom, second player on top of Screen)
bad.speed(10)
bad.shape("circle")
bad.color("yellow")
bad.penup()
bad.goto(0, 250) # y is postive in the up direction y is negative in the down direction
bad.speed = random.randint(5, 8)
bads.append(bad)
#Functions
def go_left():
player.direction = "left"
def go_right():
player.direction = "right"
#keyboard Binding
ms.listen() # it is bascally saying listen for keyboard input < ^ >
ms.onkeypress(go_left, "Left")
ms.onkeypress(go_right, "Right")
#Main game loop # while something is true it will repeat
while True:
# update screen
ms.update()
#Move player
if player.direction == "left":
x = player.xcor()
x -= + 3
player.setx(x)
if player.direction == "right":
x = player.xcor()
x += + 3
player.setx(x)
# Move Good Player
for good in goods:
y = good.ycor()
y -= good.speed # We want the ball to be falling at a smooth speed
good.sety(y)
# Check it off the Screen
if y < -300:
x = random.randint(-380, 380)
y = random.randint(300, 400)
good.goto(x, y)
# check for collision with player
if good.distance(player) < 20:
x = random.randint(-380, 380)
y = random.randint(300, 400)
good.goto(x, y)
# Move bad Player
for bad in bads:
y = bad.ycor()
y -= bad.speed # We want the ball to be falling at a slow speed
bad.sety(y)
# Check it off the Screen
if y < -300:
x = random.randint(-380, 380)
y = random.randint(300, 400)
bad.goto(x, y)
# check for collision with player
if bad.distance(player) < 20:
x = random.randint(-380, 380)
y = random.randint(300, 400)
bad.goto(x, y)
ms.mainloop()
If I understand your need, you want good guys and bad guys to move at different speeds. A key to this is understanding there are two concepts of speed at work in the program: turtle's speed() method:
player.speed(0)
good.speed(0)
bad.speed(10)
This one has to do with how fast the graphics are drawn, and not what we're interested in. And the game's own instance variable speed that the author hangs off of turtle instances:
good.speed = randint(5, 8)
bad.speed = randint(5, 8)
y -= good.speed
y -= bad.speed
Which probably shouldn't be called .speed since the turtle already has a .speed method. So we'll rename this to .velocity. This speed is how fast the object moves on the screen, and what we're interested in.
You changed the wrong one by setting good.speed(0) and bad.speed(10) which since they are not drawing, just moving turtle cursors, has little effect. What we want to do instead is change:
good.velocity = randint(1, 4) # was .speed
bad.velocity = randint(5, 8) # was .speed
And fix all our other uses of the .speed instance variable to be .velocity:
y -= good.velocity # was .speed
y -= bad.velocity # was .speed
I've made this change, among others, to the code below. You'll see that the good guys move about 2.5X faster than the bad guys:
# Our module's
from turtle import Screen, Turtle
from random import randint
# Functions
def go_left():
player.direction = 'left'
def go_right():
player.direction = 'right'
# Screen
screen = Screen()
screen.setup(width=800, height=600)
screen.title("Falling Piece's mini_game by Rafa94")
screen.bgcolor('purple')
screen.tracer(0)
# player
player = Turtle()
player.shape('turtle')
player.speed('fastest')
player.color('blue')
player.penup()
player.sety(-250) # y is positive in the up direction; negative in the down direction
player.direction = 'stop'
# Create a list of good players
# Good represents good_player
goods = [] # Empty list
# Add good players
for _ in range(20): # We are making a set of 20 players
# We want the other players basically across from each other
# thats we copyied the code one on -y and one on +y (first
# player in the bottom, second player on top of Screen)
good = Turtle()
good.shape('circle')
good.speed('fastest')
good.color('red')
good.penup()
good.goto(-100, 250) # y is positive in the up direction; negative in the down direction
good.velocity = randint(1, 4)
goods.append(good)
# Create a list of bad players
# Bad represents bad_players
bads = [] # Empty list
# Add bad players
for _ in range(20): # we are making a set of 20 players
# We want the other player basically across from each other
# thats we copyied the code one on -y and one on +y (first
# player in the bottom, second player on top of Screen)
bad = Turtle()
bad.shape('circle')
bad.speed('fastest')
bad.color('yellow')
bad.penup()
bad.goto(100, 250) # y is positive in the up direction; negative in the down direction
bad.velocity = randint(5, 8)
bads.append(bad)
# Keyboard Binding
screen.onkeypress(go_left, 'Left')
screen.onkeypress(go_right, 'Right')
screen.listen() # Basically saying listen for keyboard input
# Main game loop
# While something is true it will repeat
while True:
# Move player
x = player.xcor()
if player.direction == 'left':
x -= 3
elif player.direction == 'right':
x += 3
player.setx(x)
# Move Good Player
for good in goods:
y = good.ycor() - good.velocity # We want the ball to be falling at a smooth speed
good.sety(y)
if y < -300:
# Check if it's off the Screen
x = randint(-380, 380)
y = randint(300, 400)
good.goto(x, y)
elif good.distance(player) < 20:
# Check for collision with player
x = randint(-380, 380)
y = randint(300, 400)
good.goto(x, y)
# Move bad Player
for bad in bads:
y = bad.ycor() - bad.velocity # We want the ball to be falling at a slow speed
bad.sety(y)
if y < -300:
# Check if it's off the Screen
x = randint(-380, 380)
y = randint(300, 400)
bad.goto(x, y)
elif bad.distance(player) < 20:
# Check for collision with player
x = randint(-380, 380)
y = randint(300, 400)
bad.goto(x, y)
# Update screen
screen.update()
screen.mainloop()
Related
I'm making a rip-off game that's based on those magic tile games where you tap your finger at one of 4 sections at the bottom to play a note. It is always sideways instead. Right now I"m working on letting the player (the black square on the left) move while the animation for the colored tiles is moving. Right now it is just before the functions that draw the tiles, and I have tried putting the functions within the function that makes the tiles.
import turtle as trtl
import random as rand
leader_colors = []
wn = trtl.Screen()
player = trtl.Turtle()
player.speed(150)
player.penup()
player.shape("square")
player.shapesize(7.5)
player.goto(-850,0)
player.speed(50)
def goUp():
y = player.ycor()
player.goto(-850, y + 150)
def goDown():
y = player.ycor()
player.goto(-850, y - 150)
def tileMaker1(many):
distance = 0
length = 0
postion = 1420
for i in range(many):
i = trtl.Turtle()
i.hideturtle()
i.penup()
i.pensize(145)
i.pencolor("white")
i.shapesize(175)
i.pensize(145)
i.penup()
i.setheading(180)
i.penup()
i.shape("square")
i.shapesize(7.2)
i.hideturtle()
i.goto(postion, 0)
i.showturtle()
i.penup()
while distance < 51:
i.color("blue")
i.forward(50)
distance += 1
length += 50
wn.onkeypress(goUp, "Up")
wn.onkeypress(goUp, "w")
wn.onkeypress(goDown, "Down")
wn.onkeypress(goDown, "s")
tileMaker1(4)
I want to make a Space Invaders game but my enemies don't disappear if they get hit. Does anyone know how to fix it?
I already tried a for loop (as you will see) but it doesnt work:
import turtle as tr
wn = tr.Screen()
wn.tracer(0)
bullet = tr.Turtle()
player = tr.Turtle()
enimis = []
y = -250
def shoot():
player.direction = "up"
wn.onkey(shoot,"space")
while True:
if len(enimis) == 0:
for u in range(-210,210,60):
for o in range(100,260,60):
enimi = tr.Turtle()
enimi.setpos(u,o)
enimis.append(enimi)
if player.direction == "up":
bullet.penup()
x = player.xcor()
bullet.setpos(x,y)
bullet.pendown()
for p in range(550):
bullet.setpos(x,y+p)
for k in enimis:
if bullet.distance(k) < 25:
score += 10
if score > highscore:
highscored = True
else:
highscored = False
del k
hit = True
break
else:
hit = False
wn.update()
There aren't any error messages, the enemies just don't disappear.
I don't see why you're stuck on making dead enemies disappear when the code doesn't run at all due to this error:
if player.direction == "up":
AttributeError: 'Turtle' object has no attribute 'direction'
Nor could you hit an enemy since your player and enemies can't move and the player isn't pointing at an enemy to start with. Too much magical thinking and not enough code.
To answer your question, this can't work:
for k in enimis:
if bullet.distance(k) < 25:
# ...
del k
# ...
break
It either needs to be:
for k in enimis:
if bullet.distance(k) < 25:
# ...
enimis.remove(k) # remove by value
# ...
break
or:
for k in range(len(enimis)):
if bullet.distance(enimis[k]) < 25:
# ...
del enimis[k] # remove by index
# ...
break
Below is my complete rewrite of your code to get it to basically play: player can move left and right; bullets fire, hit enemies, score points, and enemies disappear; the score is shown on the screen; etc.
from turtle import Screen, Turtle
BASELINE = -250
FONT = ('Arial', 18, 'bold')
def left():
player.setx(player.xcor() - 5)
def right():
player.setx(player.xcor() + 5)
def shoot():
global firing
firing = True
firing = False
enemies = []
score = 0
bullet = Turtle('triangle')
bullet.hideturtle()
bullet.speed('fastest')
bullet.shapesize(0.5)
bullet.setheading(90)
bullet.penup()
player = Turtle('turtle')
player.hideturtle()
player.speed('fastest')
player.color('green')
player.setheading(90)
player.penup()
player.sety(BASELINE)
player.showturtle()
marker = Turtle()
marker.hideturtle()
marker.penup()
marker.goto(-300, 300)
marker.write("Score: {}".format(score), align='center', font=FONT)
def play():
global firing, score
if not enemies:
screen.tracer(False)
for x in range(-210, 210, 60):
for y in range(100, 260, 60):
enemy = Turtle('turtle')
enemy.color('red')
enemy.setheading(270)
enemy.penup()
enemy.setpos(x, y)
enemies.append(enemy)
screen.tracer(True)
if firing:
bullet.setx(player.xcor())
bullet.sety(BASELINE)
bullet.showturtle()
for p in range(0, 550, 5):
bullet.sety(BASELINE + p)
for enemy in enemies:
if bullet.distance(enemy) < 20:
score += 10
marker.undo()
marker.write("Score: {}".format(score), align='center', font=FONT)
enemy.clear()
enemy.hideturtle()
enemies.remove(enemy)
break
else: # no break
continue
break
bullet.clear()
bullet.hideturtle()
firing = False
screen.ontimer(play, 100)
screen = Screen()
screen.onkey(shoot, 'space')
screen.onkey(left, 'Left')
screen.onkey(right, 'Right')
screen.listen()
play()
screen.mainloop()
Still needed: moving enemies left, right and down; making bullet firing and player/enemy movement happen at the same time; add back highscore; etc.
I have gotten an issue where an enemy turtle stops when I shoot. I am relatively new to python so I know that my code is pretty bad. I cant seem to spot why this happens but I'm assuming its got something to do with the while loop.
here is the code:
(i have added notes so it is easy to skip to important parts of it)
import turtle
import os
#wn is window
#bp = border
bullet = 'ready'
#screen setup
wn = turtle.Screen()
wn.bgcolor('black')
wn.title('SPACE.INVADERS')
#border
bp = turtle.Turtle()
bp.speed(0)
bp.color('green')
bp.penup()
bp.setposition(-300,-300)
bp.pendown()
count=0
while count != 5:
count= (count+1)
bp.fd(600)
bp.lt(90)
bp.hideturtle()
#player
p = turtle.Turtle()
p.color('red')
p.shape('triangle')
p.penup()
p.speed(0)
p.setposition(0,-250)
p.setheading(90)
#enemy
e = turtle.Turtle()
e.penup()
e.speed(0)
e.shape('square')
e.shapesize(1.25,1.25)
e.color('orange')
e.setpos(-250,250)
e.speed(1)
#p = player
#ps = player speed
ps = 15
#moving left and right
def left_mov():
x = p.xcor()
x -= ps
p.setx(x)
def right_mov():
x = p.xcor()
x += ps
p.setx(x)
#shooting
def shoot():
global bullet
if bullet == 'ready':
bullet = 'fire'
shot= turtle.Turtle()
shot.penup()
shot.speed(0)
shot.goto(p.pos())
shot.color('white')
shot.shape('triangle')
shot.shapesize(0.5)
shot.lt(90)
shot.speed(1)
shot.fd(550)
bullet = 'ready'
#bindings
turtle.listen()
turtle.onkey(left_mov, 'Left')
turtle.onkey(right_mov, 'Right')
turtle.onkey(shoot, 'space')
#enemy movement
while True:
e.fd(500)
e.rt(90)
e.fd(25)
e.rt(90)
e.fd(500)
e.lt(90)
e.fd(25)
e.lt(90)
I'm assuming its got something to do with the while loop
Yes, it shouldn't be there! In an event-driven world like turtle, there should never be a while True: loop. Instead, we need a timer event that fires off on regular intervals that does incremental updates of the objects in motion (enemy and bullet) so they appear to move at the same time. Below is my rework of your code using a timer event:
from turtle import Screen, Turtle
# moving left and right
def left_move():
player.setx(player.xcor() - player_speed)
def right_move():
player.setx(player.xcor() + player_speed)
# screen setup
screen = Screen()
screen.bgcolor('black')
screen.title('SPACE.INVADERS')
# border
border = Turtle(visible=False)
border.speed('fastest')
border.color('green')
border.penup()
border.setposition(-300, -300)
border.pendown()
for _ in range(4):
border.forward(600)
border.left(90)
# player
player = Turtle('triangle')
player.speed('fastest')
player.color('red')
player.penup()
player.setposition(0, -250)
player.setheading(90)
player_speed = 15
# enemy
enemy = Turtle('square')
enemy.speed('fast')
enemy.shapesize(1.25)
enemy.color('orange')
enemy.penup()
enemy.setpos(-250, 250)
enemy_speed = 6 # enemy speed
enemy_direction = 1 # enemy direction
# bullet
bullet = Turtle('triangle', visible=False)
bullet.speed('fastest')
bullet.color('white')
bullet.shapesize(0.5)
bullet.penup()
bullet.left(90)
bullet_speed = 9 # bullet speed
# shooting
def shoot():
if not bullet.isvisible():
bullet.goto(player.position())
bullet.showturtle()
def move():
global enemy_direction
if bullet.isvisible():
if bullet.ycor() > 275:
bullet.hideturtle()
else:
bullet.forward(bullet_speed)
# enemy movement
enemy.forward(enemy_direction * enemy_speed)
enemy.settiltangle(enemy.tiltangle() + 3) # just for fun
x, y = enemy.position()
if x > 250 or x < -250:
enemy_direction *= -1
enemy.sety(y - 25)
screen.ontimer(move, 50)
# bindings
screen.onkey(left_move, 'Left')
screen.onkey(right_move, 'Right')
screen.onkey(shoot, 'space')
screen.listen()
move()
screen.mainloop()
This should give you the basic functionality you need to move forward and add collision detection (bullet to enemy, enemy to player, player to wall) and scoring.
Also note that turtles are global entities so creating a new bullet every time you need one is a bad idea. Even if you evenually allow overlapping bullets, keep a reusable set of bullets for that purpose.
I have found a "flappy game" project and I am modifying it to my liking.
I would like to know how I can control the definition "tap" with the keyboard and not with the mouse (I have tried the online code "onkey" and it did not work) and I would like to know if I can add a score.
Next I attach the code that I have in possession at the moment and I would appreciate some feedback.
from random import *
from turtle import *
from freegames import vector
bird = vector(0, 0)
balls = []
def tap(x, y):
"Move bird up in response to screen tap."
up = vector(0, 30)
bird.move(up)
def inside(point):
"Return True if point on screen."
return -200 < point.x < 200 and -200 < point.y < 200
def draw(alive):
"Draw screen objects."
clear()
goto(bird.x, bird.y)
if alive:
dot(10, 'green')
else:
dot(10, 'red')
for ball in balls:
goto(ball.x, ball.y)
dot(20, 'black')
update()
def move():
"Update object positions."
bird.y -= 5
for ball in balls:
ball.x -= 3
if randrange(10) == 0:
y = randrange(-199, 199)
ball = vector(199, y)
balls.append(ball)
while len(balls) > 0 and not inside(balls[0]):
balls.pop(0)
if not inside(bird):
draw(False)
return
for ball in balls:
if abs(ball - bird) < 15:
draw(False)
return
draw(True)
ontimer(move, 50)
setup(420, 420, 370, 0)
hideturtle()
up()
tracer(False)
onscreenclick(tap)
move()
done()
I've tried all kinds of functions and none has worked.
I would like to know how I can control the definition "tap" with the
keyboard and not with the mouse
That should be as simple as replacing:
onscreenclick(tap)
with
onkey(tap, "Up")
listen()
and dropping the x and y arguments to tap(). I've reworked your code below to make this change as well as eliminate:
from freegames import vector
and make it run just with what's available in turtle. I also changed the logic of keeping vectors and having the default turtle draw dots in their locations to instead making the balls and bird all turtles and just moving them as needed. Since turtles aren't garbage collected normally, I keep a list of balls that have gone off screen to reuse again:
from random import randrange
from turtle import Turtle, Screen
BIRD_RADIUS = 10
BALL_RADIUS = 20
CURSOR_SIZE = 20
WINDOW_WIDTH, WINDOW_HEIGHT = 420, 420
GALLERY_WIDTH, GALLERY_HEIGHT = WINDOW_WIDTH - BALL_RADIUS, WINDOW_HEIGHT - BIRD_RADIUS
def click():
"Move bird up in response to screen key click."
bird.forward(min(BIRD_RADIUS * 3, WINDOW_HEIGHT/2 - bird.ycor())) # flying higher
def is_ball_inside(turtle):
"Return True if point on screen."
x = turtle.xcor()
return -GALLERY_WIDTH/2 < x
def is_bird_inside(turtle):
"Return True if point on screen."
y = turtle.ycor()
return -GALLERY_HEIGHT/2 < y < GALLERY_HEIGHT/2
def draw(is_alive):
"Draw screen objects."
if not is_alive:
bird.color('red')
screen.update()
def move():
"Update object positions."
if not is_bird_inside(bird):
draw(False) # flew or fell out of gallery
return
bird.backward(BIRD_RADIUS/2) # falling to earth
for ball in balls:
ball.forward(3)
for ball in balls:
if ball.distance(bird) < (BIRD_RADIUS + BALL_RADIUS) / 2:
draw(False)
return
while balls and not is_ball_inside(balls[0]):
ball = balls.pop(0)
ball.hideturtle()
spare_balls.append(ball) # reduce, reuse, recycle
if randrange(10) == 0:
ball = spare_balls.pop() if spare_balls else Turtle("circle", visible=False)
ball.shapesize(BALL_RADIUS / CURSOR_SIZE)
ball.setheading(180)
ball.penup()
ball.goto(GALLERY_WIDTH/2, randrange(BALL_RADIUS - GALLERY_HEIGHT/2, GALLERY_HEIGHT/2 - BALL_RADIUS))
ball.showturtle()
balls.append(ball)
draw(True)
screen.ontimer(move, 50)
screen = Screen()
screen.setup(WINDOW_WIDTH, WINDOW_HEIGHT + 10) # little bit added for title bar
bird = Turtle("circle", visible=False)
bird.shapesize(BIRD_RADIUS / CURSOR_SIZE)
bird.color("green")
bird.setheading(90)
bird.penup()
bird.showturtle()
balls = []
spare_balls = []
screen.tracer(False)
screen.onkey(click, "Up")
screen.listen()
move()
screen.mainloop()
To make the turtle window the keyboard listener, you need to touch it with the mouse, to make it active, before hitting the up arrow key.
Before adding the current score to the window, you need to define how one scores. (Is it the number of ball successfully dodged?) Here I would use an additional, invisible turtle stationed in a fixed position that just does undo() and write() to update the scrore.
I wanted to make a snake game in turtle but I can't seem to get the tail segments to follow the leader. As if to say I can't get the first body part to follow the head, and then the second body part to follow the first body, etc.
I tried using what maths I have but I can't seem to get it to calculate where the head just was or where the body in front of it just was.
here is my code:
#libraries
import turtle
import random
import math
#screen
the_screen = turtle.Screen()
the_screen.bgcolor("lightgreen")
the_screen.title("Catapillar")
#border
border_writer = turtle.Turtle()
border_writer.speed(0)
border_writer.color("green")
border_writer.penup()
border_writer.setposition(-275, -275)
border_writer.pendown()
border_writer.pensize(7)
for side in range(4):
border_writer.fd(550)
border_writer.lt(90)
border_writer.hideturtle()
#player
player = turtle.Turtle()
player.color("yellow")
player.shape("circle")
player.penup()
player.speed(0)
player.setposition(0,0)
player.setheading(0)
playerspeed = 2
#fruit
fruit = 1
fruit = turtle.Turtle()
fruit.color("red")
fruit.shape("circle")
fruit.penup()
fruit.speed(0)
fruit.shapesize(0.6, 0.6)
x = random.randint(-200, 200)
y = random.randint(100, 250)
fruit.setposition(x, y)
#moving and collision checker
def turnleft():
player.left(24.5)
def turnright():
player.right(24.5)
def increasespeed():
global playerspeed
playerspeed += 1
def isCollision(t1, t2):
distance = math.sqrt(math.pow(t1.xcor()-t2.xcor(), 2) + math.pow(t1.ycor()-t2.ycor(), 2))
if distance < 24:
return True
else:
return False
#making the tail(s) and hiding them
tail1 = turtle.Turtle()
tail1.hideturtle()
tail1.color("yellow")
tail1.shape("circle")
tail1.penup()
tail1.speed(0)
tail1.setposition(+700,700)
tail1.shapesize(0.6, 0.6)
tail1state = 'off'
#key presses
turtle.listen()
turtle.onkeypress(turnleft, "Left")
turtle.onkeypress(turnright, "Right")
turtle.onkeypress(increasespeed, "Up")
#main loop player always moves forward, out of bound set, reset fruit
#randomly when collided, create tail1...
while True:
player.forward(playerspeed)
#gameovers'
if (player.xcor() > 275) or (player.xcor() < -275):
playerspeed += 7
print("GAME OVER")
if (player.ycor() > 275) or (player.ycor() < -275):
playerspeed += 7
print("GAME OVER")
#collision check between fruit and head
if isCollision(player, fruit):
#resets the fruit, moves it randomly
fruit.hideturtle()
if tail1state == 'off':
uuu = player.xcor()
vvv = player.ycor()
tail1.setposition(uuu,vvv)
tail1.showturtle()
tail1state = 'on'
#reset the fruit
x = random.randint(-200, 200)
y = random.randint(-100, 250)
fruit.setposition(x, y)
fruit.showturtle()
#playerspeed +=1
If you have any idea on how you think I should approach it, please let me know what you think.
Thank you.
Since this comes up over and over (but effort to effect it is rarely shown) here's my minimal, generic, slithering around a screen effect that you should be able to adapt for your own purposes:
from turtle import Turtle, Screen
SNAKE_LENGTH = 10
SNAKE_SIZE = 15
WIDTH, HEIGHT = 375, 375
CURSOR_SIZE = 20
def slither():
segment = snake[-1].clone() if len(snake) < SNAKE_LENGTH else snake.pop(0)
screen.tracer(False) # segment.hideturtle()
segment.setposition(snake[-1].position())
segment.setheading(snake[-1].heading())
segment.forward(SNAKE_SIZE)
while not -WIDTH/2 < segment.xcor() < WIDTH/2 or not -HEIGHT/2 < segment.ycor() < HEIGHT/2:
segment.undo()
segment.right(95)
segment.forward(SNAKE_SIZE)
screen.tracer(True) # segment.showturtle()
snake.append(segment)
screen.ontimer(slither, 100)
boundary = Turtle(shape='square', visible=False)
boundary.shapesize(HEIGHT / CURSOR_SIZE, WIDTH / CURSOR_SIZE)
boundary.fillcolor("white")
boundary.stamp()
head = Turtle("circle")
head.shapesize(SNAKE_SIZE / CURSOR_SIZE)
head.penup()
snake = [head]
screen = Screen()
slither()
screen.exitonclick()