CMPT120 Assignment 2- Automatic Crowds Solution

Nobody goes there anymore. It's too crowded.
You've probably seen movies with huge crowds of people. While they might sometimes have real people, nowadays crowds are often computergenerated. This gives the film-makers more control over their size and behaviour, and probably saves them money as well.
So in this assignment, we'll explore how to make a simple crowd scene using turtle graphics.
Answer the questions below in order: later questions depend upon earlier ones. Use exactly the function name and parameters as given in the question, put all your functions into a single Python file named a2.py. Please include your name and email at the top of a2.py formatted like this: ```python
Full Name:
SFU Email:
```
When you're done, submit your finished a2.py file on Canvas.
Question 1: Regular Polygons
Write a function called polygon(n, size) that uses turtle graphics to draw an $n$-sided regular polygon with each side of length size.
Use this algorithm:
Set the turning $mathit{angle}$ to be $rac{360}{n}$.
Do the following $n$ times:
draw a line of length size turn left $mathit{angle}$ degrees
For example, here is a pentagon (a 5-sided polygon):

Question 2: Jumping
Write a function called jump_to(x, y) that moves the turtle to position (x, y) without drawing a line. After the turtle has jumped to (x, y) its pen should be down, ready to draw.
turtle.goto(x, y) will move the turtle to (x, y), but if the pen is down it will draw an unwanted line.
In the following functions, use jump_to to move the turtle to its correct starting point.

These four pentagons are one example of something you can draw using polygon and jump_to. You don't need to submit it with your assignment. But a good way to test jump_to is to write a function called test_jump_to() that draws theses 4 pentagons, or some other picture.
Question 3: Circles
Write a function called circle(radius) that draws a circle whose radius is radius. To draw a circle in turtle graphics, just draw a polygon with lots of sides, say 50 - 100.
Important Don't call the turtle.circle(r) to draw this circle. Use just your polygon function.
To calculate the size (length) of the polygon edges, use this formula inside your circle function:
$$mathit{size} = 2 mathit{r} sin rac{pi}{n}$$
Here, $r$ is the radius passed to circle, and $n$ is the number sides of the polygon.
The sin function, and pi, are in Python's math module.

Question 4: Eyes
Write a function called eye(radius) that draws one (cartoon) eye using two circles: a big circle, and a filled-in smaller circle inside the big one (representing the pupil).
Use the turtle.begin_fill() and turtle.end_fill() functions to fill-in the smaller circle.
Here's an example:

Question 5: Noses
Write a function called nose(size) that draws a (cartoon) nose that consists of, at least, two different shapes. The exact style and look of the nose is up to you. It could be as simple as an upside-down 7.
As with mouth, what exactly size means is up to you. Make it so that the bigger size is, the bigger the nose.

Question 6: Mouths
Write a function called mouth(size, style) that draws a (cartoon) mouth as follows:
If style == 'happy', the mouth is drawn smiling.
If style == 'sad', the mouth is drawn frowning.
If style == surprised, the mouth is drawn as a circle.
For any other value of style, the mouth is drawn as a neutral expression, e.g. a straight line.
What exactly size means is up to you. Make it so that the bigger size is, the bigger the mouth.
Here are examples of the four mouths:

Question 7: Heads
Write a function called head(size) that draws a (cartoon) head that consists of, at least, two eyes, a random mouth, a nose, and a head (e.g. a circle) all around it. Use the functions you wrote above to draw the eyes, mouth, and nose.
Choose the mouth style at random to be one of the 4 mouth shapes.
The size of the head should be controllable using size, e.g. a small value of size should draw a small head, and a big value should draw a big head. Make sure all the eyes, nose, and mouth fit into it snugly and are proportional to the size.
For instance, a head with a surprised face could look like this:

Question 8: Stick Figures
Write a function called stick_figure(size) that adds a head (using head), and a body underneath it. It should have, at least, a torso (maybe just a line), arms, and legs. They can be simple stick figures if you like, or more elaborate.
Include some randomness in the body beyond just the mouth randomness. For example, you could chose the color at random, or make the arms point in random directions, or draw the body with different thicknesses, etc.

Question 9: Crowds
Write a function called crowd(n, min_size, max_size) that draws n stick figures (using your stick_figure function) at random locations on the screen. The size of each stick figure should be chosen at random in the range min_size to max_size.
Marking Scheme
1 mark overall: consistent indentation and spacing (all blank lines and spaces should have a good reason for being there) 1 mark overall: all variable names are self-descriptive
1 mark overall: the length of all lines are less than, or equal to, 100 characters
Hints
In addition to calling turtle.speed('fastest') or turtle.hideturtle(), you can speed up drawing quite a bit with this code: ```python turtle.Screen().tracer(0) # don't show any drawing on the screen
... draw stuff here ...
turtle.Screen().update() # refresh the screen to see what was drawn ```
If you want to save a turtle position to come back to later, you can do this: ```python x, y = turtle.position()
# ... do stuff ...
jump_to(x, y) # go back to location (x, y) ```
To make the turtle face a particular direction, use one of these:
python turtle.setheading(0) # face east turtle.setheading(90) # face north turtle.setheading(180) # face west turtle.setheading(270) # face south