Added namespace to all turtle functions

foonicorn · foonicorn · commit a31a35dc59d0 · 2012-08-30T18:55:50.000+02:00
diff --git a/docs/en/conditional_loops.rst b/docs/en/conditional_loops.rst
@@ -28,8 +28,8 @@ Solution
 ::
 
     def move_to_window_border(distance):
-        while xcor() + distance < window_width() / 2:
-            forward(distance)
+        while turtle.xcor() + distance < turtle.window_width() / 2:
+            turtle.forward(distance)
 
 Bonus
 -----
@@ -47,8 +47,8 @@ Exercise
 
 Write a ``while`` loop with a condition that is always true to draw a spiral.
 Interrupt the loop when the turtle reaches a certain distance from the center.
-Use the function ``distance(x, y)`` to get the turtle's distance to the point
-defined by the coordinates ``x`` and ``y``.
+Use the function ``turtle.distance(x, y)`` to get the turtle's distance to the
+point defined by the coordinates ``x`` and ``y``.
 
 .. note::
 
@@ -63,9 +63,9 @@ Solution
     def draw_spiral(radius):
         speed = 1
         while True:
-            forward(speed)
-            left(10)
+            turtle.forward(speed)
+            turtle.left(10)
             speed += 0.1
-            if distance(0, 0) > radius:
+            if turtle.distance(0, 0) > radius:
                 break
 
diff --git a/docs/en/conditionals.rst b/docs/en/conditionals.rst
@@ -28,10 +28,10 @@ Here are some simple examples::
 
     direction = -30
     if direction > 0 :
-        forward(direction)
+        turtle.forward(direction)
     else:
-        left(180)
-        forward (-direction)
+        turtle.left(180)
+        turtle.forward (-direction)
 
 
 Condition an action
@@ -47,22 +47,22 @@ We want the turtle to go forward for a specified distance (taken as a function p
 .. note::
  * We start from the center of the screen, which has coordinate (0;0)
  * We won't turn, until we reach the boundary our turtle wants to get away as quickly as possible
- * We can get the x coordinate of our turtle with the function *xcor*
- * We can get the width of the screen with the function *window_width*
+ * We can get the x coordinate of our turtle with the function ``turtle.xcor()``
+ * We can get the width of the screen with the function ``turtle.window_width()``
 
 Solution
 --------
 
 ::
 
     def stop_at_end_of_screen(distance):
-        future_x_coord = xcor() + distance
-        diff = window_width()/2-future_x_coord
+        future_x_coord = turtle.xcor() + distance
+        diff = turtle.window_width()/2 - future_x_coord
         if  diff > 0 :
-            forward(distance)
+            turtle.forward(distance)
         else:
-            forward(window_width()/2-xcor())
-            left(180)
+            turtle.forward(turtle.window_width()/2 - turtle.xcor())
+            turtle.left(180)
 
 Bonus exercise
 --------------
@@ -71,27 +71,24 @@ Now when the turtle reaches the end of the screen, it turns around and
 continue its movement in the other direction, the remaining of the distance
 
 .. note::
- * heading() gives you the current angle the turtle's direction makes with the original east facing turtle. (a turtle going straight up has a heading of 90 degrees)
+ * turtle.heading() gives you the current angle the turtle's direction makes with the original east facing turtle. (a turtle going straight up has a heading of 90 degrees)
 
 Solution
 --------
 
 ::
 
     def uturn_at_border(distance):
-        if heading() == 0 :
-            future_x_coord = xcor() + distance
+        if turtle.heading() == 0 :
+            future_x_coord = turtle.xcor() + distance
         else:
-            future_x_coord = xcor() - distance
+            future_x_coord = turtle.xcor() - distance
         
-        diff = window_width()/2-future_x_coord
+        diff = turtle.window_width()/2 - future_x_coord
         if  diff > 0 :
-            forward(distance)
+            turtle.forward(distance)
         else:
-            forward(window_width()/2-xcor())
-            left(180)
+            turtle.forward(turtle.window_width()/2 - turtle.xcor())
+            turtle.left(180)
             forward (-diff)
         
-
-
-
diff --git a/docs/en/functions.rst b/docs/en/functions.rst
@@ -9,8 +9,8 @@ There is still a lot of duplicated code --- the actual drawing of the rectangle
 lacking abstractions. (Programmers call it a *code smell.*)
 
 Functions are one way to express abstractions in Python. Let's take
-``reset()`` for example. It is actually an abstraction for a number of steps,
-namely:
+``turtle.reset()`` for example. It is actually an abstraction for a number of
+steps, namely:
 
 * Erase the drawing board
 * Set the width and color back to default
@@ -19,15 +19,15 @@ namely:
 A function can be defined with the ``def`` keyword in Python::
 
     def line_without_moving():
-        forward(50)
-        backward(50)
+        turtle.forward(50)
+        turtle.backward(50)
 
 You can access names in functions as well::
 
     size = 50
     def line_without_moving():
-        forward(size)
-        backward(size)
+        turtle.forward(size)
+        turtle.backward(size)
 
 .. note:: Python uses *whitespaces to identify blocks of code* belonging together. While other languages use special characters (like curly brackets) in python a block is introduced with a colon at the end of the line and commands within a deeper identation level - ususally 4 spaces. The block ends with the first line with a lesser identation level.
 
@@ -61,40 +61,40 @@ Solution
 ::
 
     def hexagon():
-        forward(100)
-        left(60)
-        forward(100)
-        left(60)
-        forward(100)
-        left(60)
-        forward(100)
-        left(60)
-        forward(100)
-        left(60)
-        forward(100)
-        left(60)
+        turtle.forward(100)
+        turtle.left(60)
+        turtle.forward(100)
+        turtle.left(60)
+        turtle.forward(100)
+        turtle.left(60)
+        turtle.forward(100)
+        turtle.left(60)
+        turtle.forward(100)
+        turtle.left(60)
+        turtle.forward(100)
+        turtle.left(60)
 
     hexagon()
-    forward(100)
-    right(60)
+    turtle.forward(100)
+    turtle.right(60)
 
     hexagon()
-    forward(100)
-    right(60)
+    turtle.forward(100)
+    turtle.right(60)
 
     hexagon()
-    forward(100)
-    right(60)
+    turtle.forward(100)
+    turtle.right(60)
 
     hexagon()
-    forward(100)
-    right(60)
+    turtle.forward(100)
+    turtle.right(60)
 
     hexagon()
-    forward(100)
-    right(60)
+    turtle.forward(100)
+    turtle.right(60)
 
     hexagon()
-    forward(100)
-    right(60)
+    turtle.forward(100)
+    turtle.right(60)
 
diff --git a/docs/en/functions_parameters.rst b/docs/en/functions_parameters.rst
@@ -10,14 +10,14 @@ That is why we need to be able to give parameters, or also called *arguments* so
 Remember how we defined the function ``line_without_moving`` in the previous section::
 
     def line_without_moving():
-        forward(50)
-        backward(50)
+        turtle.forward(50)
+        turtle.backward(50)
 
 We can improve it by giving it a parameter::
 
     def line_without_moving(length):
-        forward(length)
-        backward(length)
+        turtle.forward(length)
+        turtle.backward(length)
 
 The parameter acts as a *name* only known inside the function's definition. We use the newly defined function by calling it with the value we want the parameter to have like this::
 
@@ -29,10 +29,10 @@ We have been using functions with parameters since the beginning of the tutorial
 
 And we can put as many arguments (or parameters) as we want, separating them with commas and giving them different names::
 
-   def tilted_line_without_moving(length,angle):
-        left(angle)
-        forward(length)
-        backward(length)
+   def tilted_line_without_moving(length, angle):
+        turtle.left(angle)
+        turtle.forward(length)
+        turtle.backward(length)
 
 
 A parameterized function for a variable size hexagon
@@ -60,12 +60,12 @@ Solution
     
     def hexagon(size):
         for i in range(6):
-            forward(size)
-            left(60)
+            turtle.forward(size)
+            turtle.left(60)
             
-    def honeycomb(size,count):
+    def honeycomb(size, count):
         for i in range(count):
             hexagon(size)
-            forward(size)
-            right(60)
+            turtle.forward(size)
+            turtle.right(60)
 
diff --git a/docs/en/logical_operators.rst b/docs/en/logical_operators.rst
@@ -4,16 +4,16 @@ Logical operators
 Introduction
 ============
 
-Conditionals are a nice way to make decisions by asking if something equals true
-or not. But often one condition is not enough. For instance if we want to make a
-decision upon ``xcor()`` and ``ycor()`` we have to combine them. This can be
-done with logical operators.
+Conditionals are a nice way to make decisions by asking if something equals
+true or not. But often one condition is not enough. For instance if we want to
+make a decision upon ``turtle.xcor()`` and ``turtle.ycor()`` we have to combine
+them. This can be done with logical operators.
 
 This and that or something else
 ===============================
 
-Two easy to understand operators are ``and`` and ``or``. They do exactly whay the
-sound like: combine two statements in a way both have be true (``and``) or
+Two easy to understand operators are ``and`` and ``or``. They do exactly whay
+the sound like: combine two statements in a way both have be true (``and``) or
 one of them has to be true (``or``)::
 
     if 1 < 2 and 4 > 2:
@@ -31,7 +31,7 @@ want.
 Exercise
 --------
 
-Create a function that accepts the argument ``angel`` and moves the turtle into
+Create a function that accepts the argument ``angle`` and moves the turtle into
 that direction until either the vertical or horizontal distance to the center
 exeeds 100.
 
@@ -40,14 +40,16 @@ Solution
 
 ::
 
-    def move_to_square_border(angel):
-        left(angel)
-        while xcor() > -100 and xcor() < 100 and ycor() > -100 and ycor() < 100:
-            forward(10)
+    def move_to_square_border(angle):
+        turtle.left(angle)
+        x = turtle.xcor()
+        y = turtle.ycor()
+        while x > -100 and x < 100 and y > -100 and y < 100:
+            turtle.forward(10)
 
 Bonus
 -----
 
 Execute the ``move_to_square_border()`` function multiple times with different
-angels. Use the ``home()`` function to make the turtle jump to the center after
-each line.
+angles. Use the ``turtle.home()`` function to make the turtle jump to the
+center after each line.
diff --git a/docs/en/loops.rst b/docs/en/loops.rst
@@ -18,7 +18,8 @@ Exercise
 --------
 
 Draw a dashed line.  You can move the turtle without tracing a line behind you
-with the ``up()`` function;  put it back on the ground with ``down()``.
+with the ``turtle.up()`` function;  put it back on the ground with
+``turtle.down()``.
 
 .. image:: /images/dashed.png
 
@@ -27,10 +28,10 @@ Solution
 ::
 
     for i in range(10):
-        forward(15)
-        up()
-        forward(5)
-        down()
+        turtle.forward(15)
+        turtle.up()
+        turtle.forward(5)
+        turtle.down()
 
 Bonus
 -----
@@ -45,7 +46,7 @@ Honeycomb loops
 Exercise
 --------
 
-Take your honeycomb program and make it easier with loops.  How small can you
+Take your honeycomb program and make it easier with loops. How small can you
 get it?
 
 Solution
@@ -55,10 +56,10 @@ Solution
 
     def hexagon():
         for i in range(6):
-            forward(100)
-            left(60)
+            turtle.forward(100)
+            turtle.left(60)
 
     for i in range(6):
       hexagon()
-      forward(100)
-      right(60)
+      turtle.forward(100)
+      turtle.right(60)
diff --git a/docs/en/names.rst b/docs/en/names.rst
diff --git a/docs/en/simple_drawing.rst b/docs/en/simple_drawing.rst
