Smith College Computer Science 111 - Lab8. Fall Semester, 2006

The purpose of today's lab is to use graphics and become acquainted with object-oriented programming. You will implement the logo programming environment. First you'll work on the graphics part. Refer to ch5 of your textbooks. Section 5.8 of the textbook has a nice summary of the graphics objects.

Part 1. Boot into Linux

Start editing a file called logo.py. Before starting your main() definition type in

from graphics import *

When we use the from graphics import * statement, we can use graphics functions and objects without putting graphics. in front of each one.

Then after your def main(): type in:

    maxPix = 400
    # Create a graphics window
    win = GraphWin("Avatars", maxPix, maxPix)
    win.setBackground("white")
    win.setCoords(0,0,maxPix,maxPix)   # now 0,0 is in lower left corner

    home = Point(50,50)    # set the home point
    angle = 0              # heading angle is initialized to 0

    filename = "franklinTurtleSmall.gif"
    turtle = Image(home, filename)
    turtle.draw(win)

These are the statements that create a GraphWin object, set the coordinates, initialize variables, etc., and draw the turtle.

You are free to choose your own image of a turtle.
This should be a small .gif file (not jpg). I found mine on www.google.com in the special images section.
You could enter search keywords like "turtle" and "gif".
My image is 143 x 162 pixels, a pretty good size for a 400x400 graphics window. An added benefit of google is that it tells you the image size in pixels.
import this into python and make sure it works. You'll have to
```
getcopy graphics.py
getcopy franklinTurtleSmall.gif
```
before you can use it. Exit from emacs and invoke the python interpreter, import Lab5 and run main(). Do you see a window with Franklin the Turtle drawn in it? If not, fix it before going to the next part.
Part 2. do some more graphics
Add graphics features, one at a time, and test each before moving on to the next one.
1. We will work on the hardest part now, that is, moving forward. To get started on this, we will assume a user has typed fd num where num is some integer, and the user may have previously changed the angle from 0. We are going to let the user think in terms of units of degrees for the angle. But the math module functions that compute sine and cosine use radians as degrees.
  We need to do two things:
  1. change from degrees to radians
  2. use the math.cos() and math.sin() functions to compute the change in x and the change in y coordinates.
  To convert from degrees to radians, use this code:
```
   angRad = (2.0*math.pi)*angle/360.0
```
  Do you remember that we went over this in class? To use the cos and sin functions, place
```
import math
```
  at the top of your program and then after computing the angle in radians, insert these two lines:
```
   dx = num * math.cos(angRad)
   dy = num * math.sin(angRad)
```
  Finally, add a statement to move the turtle to the new location:
```
   turtle.move(dx,dy)
```
  To test this part, add a temporary statement to the top of the program that lets the user type in a value for num and for angle (both should be integers). Run this program and see if the turtle moves where it should.
2. Now we will start to implement the pen up (pu) and pen down (pd) commands. It's easy! Just make a boolean variable at the top of your main() definition, named pd, and assign it the boolean value True. All this means is that you add the statement
  pd = True
  When you add in the command structure in Hw8, if the turtle command is pd, you will have one statement:
```
    pd = True
```
  And if the command is pu, you will have one statement:
```
    pd = False
```
3. Now let's go back and change the statements we just made (which will be the fd num statements in hw8) so that if pd is true, a line is drawn when the turtle moves and otherwise the turtle moves and a line is not drawn. After calculating the angle in radians, and finding dx and dy, use this statement to get the turtle image location:
```
    location = turtle.getAnchor()
```
  If pd is True, the program should create a line when the turtle moves forward. The Line class expects two Point objects, the beginning and end points. The beginning point is location (where the turtle is now) and the endpoint is calculated in this way:
```
    newX = location.getX() + dx
    newY = location.getY() + dy
    endlocation = Point(newX,newY)
```
  In other words, we get the x coordinate of the beginning point (where the turtle is) and add dx, and we get the y coordinate of the beginning point and add dy. We make a new Point out of the new coordinates and assign it to endlocation.
  Now we check pd. If it is true, we make a new Line, draw it, and move the turtle. Otherwise, we move the turtle without drawing the line:
```
     if pd==True:
          l = Line(location, endlocation)
          l.draw(win)
          turtle.move(dx,dy)
     else:
          turtle.move(dx,dy)
```
  Type this all in and try it with both values of pd.
  Get this all to work before moving to the next part
4. Now see if your turtle can make a square:
5. Here's a good test, assuming the angle starts at 0:
```
pd = True
fd 150
angle = angle + 90
fd 150
angle = angle + 90
fd 150
angle = angle + 90
fd 150
```
  This should cause the turtle to draw a square.
  
  Do not move on until you get this part working!
6. Next write code to implement the backward command. This is a little trickier, but is mostly the same as the forward command. Make sure it works for the general case when the angle is not 0.
  One way to test this is to move the turtle forward then sleep for 2 seconds (import time, etc)., then move it backwards and see that it goes back to where it started.
7. Next write code to move the turtle to the home point. This is easier than the forward or backward commands because you already know the point to which to move the turtle.
8. Let me see your turtle moves before you leave. Thanks. Make sure to take Hw8 with you when you leave. Hw8 builds directly on this lab. If there's more lab time, start on Hw8 now.