def top_layer():
    turtle.clearscreen()
    screen_setup()
    stations()
    sp = turtle.Turtle()
    sp.color('white')
    sp.penup()
    
    global top_pos
    sp.setpos(top_pos)
    sp.showturtle()
    sp.speed(1)
        
    def sta1():
        turn_and_go(sp, 'sta1')
    def sta2():
        turn_and_go(sp, 'sta2')
    def sta3():
        turn_and_go(sp, 'sta3')
        
    def zoom1():
        global top_pos
        top_pos = sp.pos()
        global middle_sta1_pos
        middle_sta1_pos = 250,-150
        if sp.pos() == (200,75):
            middle_layer_sta1()
        else:
            zoom()
    turtle.onkey(sta1, 'a')
    turtle.onkey(sta2, 'b')
    turtle.onkey(sta3, 'c')
    turtle.onkey(zoom1, '=')
    turtle.listen()

def docking_layer():
    turtle.clearscreen()
    screen_setup()
    docking_port1()
    sp3 = turtle.Turtle()
    sp3.color('white')
    sp3.penup()
    sp3.speed(0)
    sp3.setpos(300, 0)
    sp3.seth(180)
    sp3.showturtle()
    speed = (10)
    def turnleft():
        sp3.left(30)
    def turnright():
        sp3.right(30)
    def forward():
        sp3.forward(speed)
    def backward():
        sp3.backward(speed)
        
    turtle.onkey(forward, 'Up')
    turtle.onkey(turnleft, 'Left')
    turtle.onkey(turnright, 'Right')
    turtle.onkey(backward, 'Down')
    turtle.onkey(middle_layer_sta1, '-')
    turtle.listen()

def zoom():
    time.sleep(0.5)
    turtle.clearscreen()
    screen_setup()
    sp2 = turtle.Turtle()
    sp2.color('white')
    sp2.penup()
    sp2.speed(0)
    sp2.setpos(250, -150)
    sp2.seth(90)
    sp2.showturtle()
    speed = (10)
    b = 2
    def turnleft():
        sp2.left(30)
    def turnright():
        sp2.right(30)
    def forward():
        sp2.forward(speed)
    def backward():
        sp2.backward(speed)    
    
            
    turtle.onkey(forward, 'Up')
    turtle.onkey(turnleft, 'Left')
    turtle.onkey(turnright, 'Right')
    turtle.onkey(backward, 'Down')
    turtle.onkey(top_layer, '-')
    turtle.listen()

    def __init__(self):
        super(LaserCannon, self).__init__()

        # Register events.  Note the function we register for 'q' is
        # a turtle function.
        turtle.onscreenclick(self.aim,1)
        turtle.onkey(self.shoot,"s")
        turtle.onkey(seeYaLater,'q')

def top_layer():
    turtle.clearscreen()
    screen_setup()
    stations()
    sp = turtle.Turtle()
    sp.color('white')
    sp.penup()
    sp.setpos(200, 75)
    sp.showturtle()
    sp.speed(1)      
    def sta1():
        sp.goto(200, 75)
    def sta2():
        sp.goto(-300, 45)
    def sta3():
        sp.goto(-100,-200)
    def zoom1():
        if sp.pos() == (200,75):
            middle_layer_sta1()
        else:
            zoom()
    turtle.onkey(sta1, 'a')
    turtle.onkey(sta2, 'b')
    turtle.onkey(sta3, 'c')
    turtle.onkey(zoom1, '=')
    turtle.listen()

	def hold(self):
		""" holds the screen open until the user clicks or types 'q' """
	
		# have the turtle listen for events
		turtle.listen()

		# hide the turtle and update the screen
		turtle.ht()
		turtle.update()

		# have the turtle listen for 'q'
		turtle.onkey( turtle.bye, 'q' )
		# have the turtle listen for a click
		turtle.onscreenclick( lambda x,y: turtle.bye() )

		# start the main loop until an event happens, then exit
		turtle.mainloop()
		exit()

def main():
    # use sys.argv if needed
    print('generating spirograph...')
    # create parser
    descStr = """This program draws spirographs using the Turtle module. 
    When run with no arguments, this program draws random spirographs.
    
    Terminology:

    R: radius of outer circle.
    r: radius of inner circle.
    l: ratio of hole distance to r.
    """
    parser = argparse.ArgumentParser(description=descStr)
  
    # add expected arguments
    parser.add_argument('--sparams', nargs=3, dest='sparams', required=False, 
                        help="The three arguments in sparams: R, r, l.")
                        

    # parse args
    args = parser.parse_args()

    # set to 80% screen width
    turtle.setup(width=0.8)

    # set cursor shape
    turtle.shape('turtle')

    # set title
    turtle.title("Spirographs!")
    # add key handler for saving images
    turtle.onkey(saveDrawing, "s")
    # start listening 
    turtle.listen()

    # hide main turtle cursor
    turtle.hideturtle()

    # checks args and draw
    if args.sparams:
        params = [float(x) for x in args.sparams]
        # draw spirograph with given parameters
        # black by default
        col = (0.0, 0.0, 0.0)
        spiro = Spiro(0, 0, col, *params)
        spiro.draw()
    else:
        # create animator object
        spiroAnim = SpiroAnimator(4)
        # add key handler to toggle turtle cursor
        turtle.onkey(spiroAnim.toggleTurtles, "t")
        # add key handler to restart animation
        turtle.onkey(spiroAnim.restart, "space")

    # start turtle main loop
    turtle.mainloop()

def start(x,y):
    turtle.onscreenclick(None)

    level_1()

    tfood = turtle.Turtle()
    tfood.hideturtle()
    tfood.pu()
    tfood.speed(0)
    tfood.shape("square")
    tfood.color("red")

    tscore = turtle.Turtle()
    tscore.hideturtle()
    tscore.pu()
    tscore.speed(0)
    tscore.goto(100,-250)
    tscore.write("Score:" + str(a[0]), align="center",font=(10))
    
    while x > -210 and x < 210 and y > -210 and y <210:
        if fcoord[2] == 0:
            food(tfood)
            fcoord[2] = 1
        turtle.onkey(u,"Up")
        turtle.onkey(l,"Left")
        turtle.onkey(r,"Right")
        turtle.onkey(d,"Down")
        turtle.listen()
        move()
        x = turtle.xcor()
        y = turtle.ycor()        
        if x > fcoord[0]*20-5 and x < fcoord[0]*20+5 and y > fcoord[1]*20-5 and y < fcoord[1]*20+5:
            fcoord[2] = 0
            tfood.clear()
            a[0] += 1
            tscore.clear()
            tscore.write("Score:" + str(a[0]), align="center",font=(10))
        
        if len(pos) > 1:
            for i in range(1,len(pos)):
                if x < pos[i][0]+5 and x > pos[i][0]-5 and y < pos[i][1]+5 and y > pos[i][1]-5:
                        tscore.clear()
                        tfood.clear()
                        gameover()
    tscore.clear()
    tfood.clear()
    gameover()

def tegn_romskip():
    turtle.penup()
    turtle.shapesize(4)
    turtle.setpos(200, 400)
    turtle.setheading(90)
    turtle.color('blue')

    turtle.onkey(snu_hoyre, 'Right')
    turtle.onkey(snu_venstre, 'Left')
    turtle.onkey(bruk_motor, 'Up')
    turtle.listen()

 def set_listeners(self):
     turtle.onscreenclick(self.clickcb, 1)
     # In OSX, ctrl-click doesn't give a button-3 click. Instead,
     # trackpad users have to enable secondary click in system
     # preferences. Then, right-clicking on trackpad generates a
     # button-2 click. I don't know what one-button mouse users can
     # do?
     turtle.onscreenclick(self.rightclickcb, 2)
     # On Linux, right-click generates a button-3 click.
     turtle.onscreenclick(self.rightclickcb, 3)
     turtle.onkey(self.spacecb, "space")
     turtle.onkey(self.savecb, "s")
     turtle.onkey(self.redisplaycb, "r")
     turtle.listen()

def main():
    descStr = "This draws spirographs with turtle graphics, if no arguments are given, random spirographs will be drawn."
    parser = argparse.ArgumentParser(description=descStr)
    #add expected args
    parser.add_argument('--sparams', nargs=3, dest='sparams', required=False,
        help="The three arguments in sparams: R, r, l.")

    #parse args
    args = parser.parse_args()

    #set width of window to 80% of screen width
    turtle.setup(width=0.8)
    #set cursor shape to turtle
    turtle.shape('turtle')
    #set title to Spirographs!
    turtle.title("Spirographs!")
    #add keyhandler to save drawings
    turtle.onkey(saveDrawing, 's')
    #start listening
    turtle.listen()

    #hide main turtle cursor
    turtle.hideturtle()


    #check for any arguments sent to --sparams and draw spirograph
    if args.sparams:
        params = [float(x) for x in args.sparams]
        #draw spiro with given params
        col = (0.0, 0.0, 0.0)
        spiro = Spiro(0, 0, col, *params)
        spiro.draw()
    else:
        #create animator objects
        span = SpiroAnimator(6)
        #add key handler to toggle cursor
        turtle.onkey(span.toggleTurtles, "t")
        #add keyhandler to restart
        turtle.onkey(span.restart, "space")

    #start main loop
    turtle.mainloop()

import turtle

turtle.penup()
turtle.ht()

def up():
    print("You pressed Up!")

def down():
    print("You pressed Down!")

def left():
    print("You pressed Left!")

def right():
    print("You pressed Right!")
    
turtle.onkey(up, 'Up')
turtle.onkey(down, 'Down')
turtle.onkey(left, 'Left')
turtle.onkey(right, 'Right')

def repeat():
    turtle.ontimer(repeat, 500)

turtle.listen() # Remember to put this after your listeners!

# functions to play with
def stamp():
  t1.stamp()
  t2.stamp()
def dot():
  t1.dot()
  t2.dot()
def testfun():
  x = t2.pen()
  t2.stamp()
  t2.pendown()
  t2.circle(100)
  t2.pen(x)

# global key event for turtle window
turtle.onkey(dot, "o")
turtle.onkey(stamp, "space")
w.onkey(testfun, "t")
w.onkey(w.bye, "x")

# extra key events for oturtles on window
t2._screen.onkey(t2.testfun,"h")

h.show(turtle._CFG)
print "use turtlekeys to move, v b m o space h t for Actions and x for close the Window"

# bind a callback on time
oldColor = None
def gruen(e):
  global oldColor
  print e

def colide(t1,t2):
        d = math.sqrt(math.pow(ugv1.xcor()-goal.xcor(),2) + math.pow(ugv1.ycor()-goal.ycor(),2))
        if d < 20:
                return True
        else:
                return False

def obstacle(t1,t2):
        d = math.sqrt(math.pow(ugv1.xcor()-green.xcor(),2) + math.pow(ugv1.ycor()-green.ycor(),2))
        if d < 30:
                ugv1.rt(30)
        
#Modo escucha de teclado
turtle.listen()
turtle.onkey(turnleft, "Left")
turtle.onkey(turnright, "Right")
turtle.onkey(speedup, "Up")
turtle.onkey(speeddown, "Down")
turtle.onkey(restart, "r")

#Inicio de movimiento
while speed>0:
        obstacle(ugv1,green)
        ugv1.forward(speed)
        
        #Mantener UGV dentro del ambiente
        if ugv1.xcor() > 300 or ugv1.xcor() < -300:
                ugv1.rt(180)

        if ugv1.ycor() > 300 or ugv1.ycor() < -300:

def docking():
    cr = turtle.Turtle()
    cr.hideturtle()
    cr.color('gray')
    cr.speed(0)
    cr.penup()
    cr.setpos(0,250)
    cr.seth(270)
    cr.pendown()
    cr.forward(500)
    cr.penup()
    cr.setpos(450,0)
    cr.seth(180)
    cr.pendown()
    cr.forward(900)
    
    def left():
      global cenx  
      global x
      x = x-10
      cenx = cenx-10
    def right():
      global cenx
      global x
      x = x+10
      cenx = cenx+10
    def up():
      global y
      global ceny
      y = y+10
      ceny = ceny+10
    def down():
      global y
      global ceny
      y = y-10
      ceny = ceny-10
    for i in range(100):
        global r
        global x
        global cens
        ma.setx(cenx)
        ma.sety(ceny)
        al.setx(x)
        al.sety(y)
        al.pendown()
        al.seth(90)
        al.clear()
        ma.clear()
        al.circle(r)
        ma.dot(cens, 'white')
        al.penup()
        r = r+1
        x = x+1
        if cens <= 10:
            cens+0.5
        turtle.onkey(left, 'Left')
        turtle.onkey(right, 'Right')
        turtle.onkey(up, 'Up')
        turtle.onkey(down, 'Down')
        turtle.listen()
        turtle.delay(50)

def main():
    display_help_window()

    scr = turtle.Screen()
    turtle.mode('standard')
    xsize, ysize = scr.screensize()
    turtle.setworldcoordinates(0, 0, xsize, ysize)

    turtle.hideturtle()
    turtle.speed('fastest')
    turtle.tracer(0, 0)
    turtle.penup()

    board = LifeBoard(xsize // CELL_SIZE, 1 + ysize // CELL_SIZE)

    # Set up mouse bindings
    def toggle(x, y):
        cell_x = x // CELL_SIZE
        cell_y = y // CELL_SIZE
        if board.is_legal(cell_x, cell_y):
            board.toggle(cell_x, cell_y)
            board.display()

    turtle.onscreenclick(turtle.listen)
    turtle.onscreenclick(toggle)

    board.makeRandom()
    board.display()

    # Set up key bindings
    def erase():
        board.erase()
        board.display()
    turtle.onkey(erase, 'e')

    def makeRandom():
        board.makeRandom()
        board.display()
    turtle.onkey(makeRandom, 'r')

    turtle.onkey(sys.exit, 'q')

    # Set up keys for performing generation steps, either one-at-a-time or not.
    continuous = False
    def step_once():
        nonlocal continuous
        continuous = False
        perform_step()

    def step_continuous():
        nonlocal continuous
        continuous = True
        perform_step()

    def perform_step():
        board.step()
        board.display()
        # In continuous mode, we set a timer to display another generation
        # after 25 millisenconds.
        if continuous:
            turtle.ontimer(perform_step, 25)

    turtle.onkey(step_once, 's')
    turtle.onkey(step_continuous, 'c')

    # Enter the Tk main loop
    turtle.listen()
    turtle.mainloop()

def move():
    din = raw_input("Go left or right? ")
    direction = din.strip().lower()
    print "okay then", direction
    if direction == "left":
        turtle.left(90)
        turtle.forward(length)
        dashforward(100)
    if direction == "right":
        turtle.right(90)
        turtle.forward(length)
        hexagon()


turtle.onkey(turtleUp, "Up")  #  90
turtle.onkey(turtleDown, "Down")  # 270
turtle.onkey(turtleLeft, "Left")  # 180
turtle.onkey(turtleRight, "Right")  #  0
turtle.onkey(togglePen, "p")
turtle.onkey(dot, "d")
turtle.onkey(lengthPlus, "bracketright")
turtle.onkey(lengthMinus, "slash")
turtle.onkey(move, "m")


def callback(e):
    print e.keysym, repr(e.char)


w = turtle.Screen()

    def middle_layer_sta1():
        time.sleep(0.5)
        turtle.clearscreen()
        screen_setup()
        station_1()
        sp2 = turtle.Turtle()
        sp2.color('white')
        sp2.penup()
        sp2.speed(0)
        global middle_sta1_pos
        sp2.setpos(middle_sta1_pos)
        sp2.seth(90)
        sp2.showturtle()
        speed = (10)
        b = 2
        def turnleft():
            sp2.left(30)
        def turnright():
            sp2.right(30)
        def forward():
            sp2.forward(speed)
        def backward():
            sp2.backward(speed)
        def zoom1():
            global middle_sta1_pos
            middle_sta1_pos = sp2.pos()
            if sp2.xcor() > -162 and sp2.xcor() < -98 and sp2.ycor() > -112 and sp2.ycor() < -64:
                docking_layer()            
                
        turtle.onkey(forward, 'Up')
        turtle.onkey(turnleft, 'Left')
        turtle.onkey(turnright, 'Right')
        turtle.onkey(backward, 'Down')
        turtle.onkey(top_layer, '-')
        turtle.onkey(zoom1,'=')
        turtle.listen()

        for i in range(1000):
            x = random.randrange(-250, 450)
            h = random.randrange(220, 340)
            ship = turtle.Turtle()
            ship.hideturtle()
            ship.color('gray')
            ship.penup()
            ship.speed(0)
            ship.setpos(x, 260)
            ship.showturtle()
            ship.speed(1)
            ship.seth(h)
            ship.forward(1000)
            if sp2.xcor() > -162 and sp2.xcor() < -98 and sp2.ycor() > -112 and sp2.ycor() < -64:
                break

def place5():
    global cur_player
    if (cur_player == 1):
        play1(5)
    elif (cur_player == 2):
        play2(5)

def place6():
    global cur_player
    if (cur_player == 1):
        play1(6)
    elif (cur_player == 2):
        play2(6)

#key listeners
turtle.onkey(place0, '1')
turtle.onkey(place1, '2')
turtle.onkey(place2, '3')
turtle.onkey(place3, '4')
turtle.onkey(place4, '5')
turtle.onkey(place5, '6')
turtle.onkey(place6, '7')

        
#drawing the board        
draw_board(START_X , START_Y)

turtle.listen()
turtle.mainloop()

player2 = turtle.Turtle()

player2.color('blue')
player2.shape('turtle')

player2.penup()
player2.goto(-160, 0)
player2.pendown()

# button functions
def k1():
    player1.forward(10)
    if player1.xcor() > 100:
        print("player 1 wins")
        window.bye()

def k2():
    player2.forward(10)
    if player2.xcor() > 100:
        print("player 2 wins")
        window.bye()
def k3():
    window.bye()

#########     
turtle.listen()
turtle.onkey(k1, "Left")
turtle.onkey(k2, "Right")
turtle.onkey(k3, 'q')