Question

import random

import turtle

def isInScreen(win,turt):

leftBound = -win.window_width() / 2

rightBound = win.window_width() / 2

topBound = win.window_height() / 2

bottomBound = -win.window_height() / 2

turtleX = turt.xcor()

turtleY = turt.ycor()

stillIn = True

if turtleX > rightBound or turtleX < leftBound:

stillIn = False

if turtleY > topBound or turtleY < bottomBound:

stillIn = False

return stillIn

def main():

wn = turtle.Screen()

# Define your turtles here

june = turtle.Turtle()

june.shape('turtle')

while isInScreen(wn,june):

coin = random.randrange(0, 2)

if coin == 0:

june.left(90)

else:

june.right(90)

june.forward(50)

wn.exitonclick()

main()

Modify the program in the following ways:

1. Write appropriate comments for this program and function. Include:
   1. A header comment for the program
   2. A header for the function describing the parameters and return value.
   3. Comment the blocks of code.
      The text has descriptions of all this, so reread that if necessary.
2. Create a new turtle, a black hole turtle, that moves to some random location on the screen and draws a black dot of diameter 100. Use the .dot function instead of .circle, since you want the turtle at the center of the figure. [As of Fall 1, 2018, there is a bug in the active code window. If you are using the textbook to write this program, use may have to use dot(50) to get the correct size black hole. If you are using a stand-alone python compiler, use dot(100).]
   This should be done in the main function before creating the randomly walking turtle.
3. Write a boolean function that has two turtles as parameters, and returns true if the turtles are within 50 units of each other and false otherwise.
   There are several ways to determine the distance between two turtles. You could use math.sqrt or math.hypot to compute the distance. If you read the turtle documentation, you may find another way as well. Talk to the instructor if you are having trouble with this. Be sure to comment this function.
4. Modify the while loop so that the program stops when the turtle leaves the screen or when it touches the black hole. Use your Boolean function from Step 3.
5. Modify the function isInScreen so that the function only returns false if the turtle wanders off the top or bottom of the screen.
   The next step is going to deal with the turtle moving off the screen horizontally.
6. Modify the body of the while loop so that if the turtle wanders off the screen either to the right or the left, it reappears on the opposite side of the screen.
7. Add another feature to your program. Either more randomness, or one more randomly walking turtle, or multiple black holes, or ???

Answer 1

'''
This program uses turtle graphics to run a turtle object across the screen. Another
turtle object is used to draw a black hole. So when the runner turtle touches the
black hole, the program stops. Otherwise, looping infinitely.
'''
import random
import turtle
import math

def isInScreen(win,turt):
'''
this method checks if the turtle is within the window bounds
:param win: window object
:param turt: turtle object
:return: True if inside, else False
'''
leftBound = -win.window_width() / 2
rightBound = win.window_width() / 2
topBound = win.window_height() / 2
bottomBound = -win.window_height() / 2
turtleX = turt.xcor()
turtleY = turt.ycor()
stillIn = True
if turtleX > rightBound or turtleX < leftBound:
stillIn = False
if turtleY > topBound or turtleY < bottomBound:
stillIn = False
return stillIn

def isClose(turt1,turt2):
'''
This method checks if two turtles are too close (distance between them is under 50)
:param turt1: first turtle
:param turt2: second turtle
:return: True if distance between turt1 and turt2 is less than or equal to 50
'''
#finding positions
pos1=turt1.pos()
pos2=turt2.pos()
#using distance formula, finding distance between two positions
#(distance= square root of [(x1-x2)^2 + (y1-y2)^2] )
distance=math.sqrt(math.pow(pos1[0]-pos2[0],2)+math.pow(pos1[1]-pos2[1],2))
if distance<=50:
#too close
return True
return False #not close

def main():
#creating window
wn = turtle.Screen()
# Defining first turtle
june = turtle.Turtle()
june.shape('turtle')
#defining turtle that draws black hole
black_hole = turtle.Turtle()
black_hole.shape('turtle')

#finding window bounds
boundX = wn.window_width() // 2
boundY = wn.window_height() // 2
#generating a random valid position on the screen
pos=(random.randint(-boundX,boundX),random.randint(-boundY,boundY))
#pen up, so no drawing will be done
black_hole.up()
#moving turtle to above position
black_hole.goto(pos)
#pen down, will draw anything now.
black_hole.down()
#drawing a black dot of diameter 100
black_hole.dot(100,'black')

#looping infinitely
while True:
#generating a value between 0 and 1
coin = random.randrange(0, 2)
#if the value is 0, turning left 90 degrees, or else turning right
if coin == 0:
june.left(90)
else:
june.right(90)
#moving 50 spaces in the above direction
june.forward(50)
#checking if two turtles are close
if isClose(june,black_hole):
#end of loop (june entered the black hole)
break
#checking if turtle is not inside window bounds
if not isInScreen(wn,june):
#finding position
pos=june.pos()
#defining new x and y positions, currently set to current positions
newX=pos[0]
newY=pos[1]
#updating x and y coordinates to emerge from other side of the window
#if any bounds are crosses
if pos[0]<-boundX:
newX=boundX-1
elif pos[0]>boundX:
newX=-boundX+1
if pos[1]<-boundY:
newY=boundY-1
elif pos[1]>boundY:
newY=-boundY+1
#pen up, no drawing
june.up()
#hiding turtle, movement will be hidden
june.ht()
#moving to new position
june.goto(newX,newY)
#pen down
june.down()
#showing turtle
june.st()
wn.exitonclick()
main()