使用TURTLE的Python游戏

Question

I am attempting to create a game where a turtle goes around and eats dots. One dot should appear. When the turtle goes over the dot, the dot that has been eaten should disappear and a new random dot should appear. Additionally, the turtles size should grow slightly each time. So far, I have this:

from turtle import *
from random import randrange

FRAMES_PER_SECOND = 10
bgcolor('black')


def turnRight():
    global turtle

    turtle.right(15)

def turnLeft():
    global turtle

    turtle.left(15)

def dotGood():
    x = randrange(-250, 250)
    y = randrange(-250, 250)
    pen1 = Pen()
    pen1.hideturtle()
    pen1.penup()
    pen1.goto(x, y)

    pen1.dot(10, "red")

def eaten(z):
    global turtle
    global moving

    if turtle == dotGood():
        z = z + .25

def move():
    global turtle
    global moving


    if moving:
        for i in range(1):
            turtle.penup()
            turtle.shape('turtle')

            size = .5
            eaten(size)
            turtle.shapesize(size, size, size)

            turtle.color('green')
            turtle.forward(10)
            ontimer(move, 10 // FRAMES_PER_SECOND)

def start():
    global moving

    moving = True
    move()

def stop():
    global moving

    moving = False


def border():
    pen1 = Pen()
    pen1.color("yellow")
    pen1.pensize(3)
    pen1.hideturtle()
    pen1.speed(0)
    pen1.penup()
    pen1.goto(-275, -275)
    pen1.pendown()
    for i in range(4):
        pen1.fd(550)
        pen1.left(90)


def main():
    border()
    dotGood()
    global turtle


    turtle = Turtle()



    onkey(turnRight, "Right")
    onkey(turnLeft, "Left")
    onkey(start, "Up")
    onkey(stop, "Down")
    listen()



if __name__ == "__main__":
    main()

Right now, all dots continually spawn instead of one at a time, the turtle doesn't grow when it goes over a dot, and the dot doesn't disappear when the turtle goes over it. What can I do to fix this?

Answer 1

1. z in eaten function is local, you miss it every time you call it.
2. dotGood doesn't return anything to compare with turtle. I guess you need to keep the last x,y can compare it with current turtle position. turtle will not equal to a drawing.

Answer 2

Problems with your implementation:

By making food a dot() , you've no way to cleanly remove it -- instead use a circle-shaped turtle and stamp() it as it returns a stamp ID that can be cleanly removed via clearstamp() .

For nicer turning, your event handlers should block out new events while they are handling the current event.

You don't understand the purpose of global -- you need it for some of your functions but not nearly as often as you declare it.

Your turtle moves too fast to control. Given you've no code to keep it within the boundaries of the screen, it's easily lost.

The following isn't finished code but implements basic functionality: you can move the turtle, food disappears when eaten and new food appears, the turtle grows visibly fatter as he eats food:

from turtle import Turtle, Screen
from random import randrange

FRAMES_PER_SECOND = 10
WIDTH, HEIGHT = 500, 500
STAMP_SIZE = 20
DOT_SIZE = 10

def turnRight():
    screen.onkey(None, 'Right')
    turtle.right(15)
    screen.onkey(turnRight, 'Right')

def turnLeft():
    screen.onkey(None, 'Left')
    turtle.left(15)
    screen.onkey(turnLeft, 'Left')

def dotGood(food):
    x = randrange(DOT_SIZE - WIDTH//2, WIDTH//2 - DOT_SIZE)
    y = randrange(DOT_SIZE - HEIGHT//2, HEIGHT//2 - DOT_SIZE)

    food.goto(x, y)

    return ((x, y), food.stamp())

def eaten(food):
    global dot

    ((x, y), stamp_id) = dot

    if abs(turtle.xcor() - x) < DOT_SIZE and  abs(turtle.ycor() - y) < DOT_SIZE:
        food.clearstamp(stamp_id)
        dot = dotGood(food)

        return True

    return False

def move():
    global score

    if not moving:
        return

    if eaten(food):
        score += 1
        turtle.shapesize((STAMP_SIZE + 5 * score) / STAMP_SIZE)

    turtle.forward(1)

    screen.ontimer(move, 10 // FRAMES_PER_SECOND)

def start():
    global moving

    moving = True
    move()

def stop():
    global moving

    moving = False

screen = Screen()
screen.setup(WIDTH, HEIGHT)
screen.bgcolor('black')

turtle = Turtle(shape='turtle')
turtle.speed('slowest')
turtle.color('green')
turtle.penup()

food = Turtle(shape='circle', visible=False)
food.speed('fastest')
food.turtlesize(DOT_SIZE / STAMP_SIZE)
food.color('red')
food.penup()

# globals

moving = False

dot = dotGood(food)

score = 0

screen.onkey(turnRight, 'Right')
screen.onkey(turnLeft, 'Left')
screen.onkey(start, 'Up')
screen.onkey(stop, 'Down')
screen.listen()

screen.mainloop()

I tossed the border code just to keep the example simpler.