Python Season 3 needs something interesting, so we will begin by designing a script language we can use for other things. This is an important concept due to it's wide range of applications in fields such as AI and robotics, system design and so forth.

We will begin with the Game class. main.py and Window.py are unchanged from a Basic Pygame Program style boilerplate.

import pygame
from Turtle import *
from TurtleProgram import *

class Game:
    def __init__(self, window):
        self.window = window
        self.screen = window.screen
        self.logo = window.logo
        self.font = window.font

        # Game Data
        self.FPS = 60
        self.clock = pygame.time.Clock()

        self.turtle = Turtle(self.window.width,
                             self.window.height)
        self.turtle.x = self.window.width//2
        self.turtle.y = self.window.height//2
        self.d = 0

        self.t = TurtleProgram(self.turtle)
        self.t.load_file("flower.t")
        for line in self.t.program:
            print(line)

        quit()

    def start(self):
        while True:
            self.checkEvents()
            self.update()
            self.draw()
            self.clock.tick(self.FPS)

    def draw(self):
        self.screen.fill((0, 0, 0))  # Clear the screen
        self.turtle.draw(self.screen)
        pygame.display.flip()

    def update(self):
        self.t.run()


    def checkEvents(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.quit()
                return

            if event.type == pygame.KEYDOWN:
                # key down event, process keys.

                if event.key == pygame.K_q:
                    self.quit()

    def drawText(self, at_x, at_y, text, color):
        text_surface = self.font.render(text, False, color)
        x = self.window.fontwidth * at_x
        y = self.window.fontheight * at_y
        self.screen.blit(text_surface, (x + 2, y))

    def quit(self):
        quit()
        exit()

Here drawText() could be removed. The new code revolves around this:

        self.turtle = Turtle(self.window.width,
                             self.window.height)
        self.turtle.x = self.window.width//2
        self.turtle.y = self.window.height//2
        self.d = 0

        self.t = TurtleProgram(self.turtle)
        self.t.load_file("flower.t")

        for line in self.t.program:
            print(line)

First we instantiate the Turtle class and give it our window information so it can create it's Turtle data. We set x and y to be the window height and width – but this can and should be moved into the Turtle constructor.

A second part includes loading an example turtle script from a file – but this could be done in the Game constructor by using self.t.add(“reset”) and so forth.

You can also remove the for loop which just prints out the program to console.

The gameworld here is the Turtle world, which is built on top of Game.py.

import pygame
import math

class Turtle:
    def __init__(self, w, h):
        # Set width and height
        self.width = w
        self.height = h

        self.color = (255, 255, 255)
        self.line_width = 1

        # Create an image surface
        self.image = pygame.Surface((w, h))

        # Reset to baseline
        self.reset()

    def draw(self, screen):
        screen.blit(self.image, (0, 0))

We begin the constructor by defining the Turtle world and the turtle itself. These two concepts could theoretically be split into two classes. But, we will have them combined for the sake of brevity, for now.

The turtle world is the self.image = pygame.Surface(). This is an image which represents what was drawn by the turtle. Our draw function just blits this to the screen. Therefore the minimum framerate is 1, i.e. we do not need a high framerate as most of the time it will display a static image. This also implies that the turtle does not need to repeatedly draw itself every frame, but this is a change that will be made later in Game.py, and is left as an exercise to the reader (for now).

In this next section of the code, we define what the turtle can do. These are the “turtle commands”. Think of them like opcodes on a CPU, with the turtle world itself (self.image) being the “computer system” such as it's memory.

    ########################################
    # Turtle Commands                      #
    ########################################

    def clear(self):
        self.image.fill((0,0,0))

    def reset(self):
        self.pen = False
        self.clear()

        self.x = self.width//2
        self.y = self.height//2
        self.d = 0

        self.turnLeft(90)

    def penUp(self):
        self.pen = False

    def penDown(self):
        self.pen = True

    def turnLeft(self, deg):
        self.d = self.d - deg

        if self.d < 0:
            self.d = self.d % 360

    def turnRight(self, deg):
        self.d = self.d + deg

        if self.d > 360:
            self.d = self.d % 360

    def forward(self, distance):
        # Get angle in radians
        a = math.radians(self.d)

        # Calculate rise and run
        rise = distance * math.sin(a)
        run = distance * math.cos(a)

        x1 = self.x
        y1 = self.y

        x2 = x1 + run
        y2 = y1 + rise

        if self.pen:
            pygame.draw.line(self.image,
                             self.color,
                             (x1, y1), (x2, y2),
                             self.line_width)
        self.x = x2
        self.y = y2

The turtle has a small number of basic commands, as follows:

• reset – This command clears the screen, lifts the pen, and resets the turtle position.
• up – this raises the pen thus turning off drawing during turtle movement.
• down – thus lowers the pen thus turning on drawing during turtle movement.
• go – This moves the turtle forward, drawing a line if the pen is down.
• left – This causes the turtle to turn a number of degrees to the left.
• right – This causes the turtle to turn to the right, similar to the left command.

Thus there are three basic movement commands (go, turn left, turn right), and three system related commands (up, down, reset).

This class clearly and succinctly defines the turtle world and the position and velocity of the turtle.

The turtle program is a way to store and deal with turtle programs (i.e. '.t files').

class TurtleProgram:
    def __init__(self, turtle):
        self.turtle = turtle
        self.program = []
        self.pc = 0

    # Erase the program
    def reset(self):
        self.program = []
        self.pc = 0

    def add(self, s):
        self.program.append(s)

    def run(self):
        self.pc = 0
        while self.pc < len(self.program):
            self.do(self.program[self.pc])
            self.pc += 1

In this beginning part of the program we define what a program is (an array of lines) and we allow for lines to be added and cleared from the program. There is also the concept of running the program. The addition of the run() command as a stub leads us to part II, the do command. Think of this like an instruction fetch cycle for a CPU, with the do() method being the actual lookup and execution of the command.

    def do(self, statement):
        # Create cmd and para based on statement.
        if ' ' in statement:
            cmd, para = statement.split(' ', 1)  # one space
            try:
                para = float(para)  # make sure it's a number.
            except:
                para = 0
        else:
            cmd, para = statement, 0  # one space

        #print(cmd, para) # for debugging

        # Comment lines -- do nothing.
        if cmd == "#":
            pass
            return

        # RESET
        if cmd == "reset":
            self.turtle.reset()
            return

        # GO
        if cmd == "go":
            self.turtle.forward(para)
            return

        # LEFT
        if cmd == "left":
            self.turtle.turnLeft(para)
            return

        # RIGHT
        if cmd == "right":
            self.turtle.turnRight(para)
            return

        # PEN UP
        if cmd == "up":
            self.turtle.penUp()
            return

        # PEN UP
        if cmd == "down":
            self.turtle.penDown()
            return

The purpose of do() is to control the turtle. It creates the idea of an automatic turtle which works on the statements of a turtle program. This program could be added manually with .add() method calls or by loading a .t file as shown below:

This is the third part of Class TurtleProgram.

    def load_file(self, filename):
        file = open(filename, "r")
        program = file.readlines()
        file.close()

        # Clean up the file.
        self.program = []
        for line in program:
            s = line.strip()
            if len(s) > 0:
                self.program.append(s)

Originally I didn't have the code which cleaned up the program and it wouldn't work. After adding this quick syntax fixer the program worked.

We encourage refactoring Turtle.py into two separate classes.

Since we are dealing with a conceptual turtle, there is no reason no to force it into a separate class.

Conceptually, TurtleWorld.py could be simply a surface in pygame. So it might not need full treatement in TurtleWorld.py class, but to keep things simple during a phase 1 refactoring we will not merge it with Game.py in the same breath as splitting it into two distinct classes.

On that note, it is easy to see a bit of a conflict in the idea of a GameWorld (in Game.py). TurtleWorld (in a theoretical TurtleWorld.py) is itself a discrete thing, which is not necessarily a game. So a good argument for leaving Game.py alone and making a TurtleWorld.py is that TurtleWorld is just data and Game.py is the projector of that world onto the screen. However in this theory Game.py would only contain calls to classes during it's lifecycle maintenance (checkEvents(), update(), render(), rinse and repeat.)

We discourage in-suite editing and saving of .t files.

There is no need to do that since they are just text files and text files are a well-established idiom on desktop PCs.

Expanding the commands of the turtle could be interesting. As a next-step project, depending on the student, we could add commands for color (and maybe alpha), then we could add commands for line width and maybe line patterns. We could also add commands for polygons, arcs, and circles.

Beyond those basic drawing ideas the fun gets in when you add line numbers and GOTOs, and then flow control like IF and so forth. Some fundamental questions to ask the student are, what changes (or what new commands) would we need to write in order to do something like the PONG game, but entirely in T (Turtle)? (Ex: A delay command, a “sheet” command, a switch-sheet command for animation, etc). What about reading the state of the pixel? Or a “goto (x,y)” command for the turtle? How interesting and complex can this become? There are many ideas and possibilities to explore!