Creative Python Programming with Strype

One small improvement to the game we can now make is to animate the astronauts. Currently, they do not move at all, which makes the scene very static. Since they are floating in space, we might start by making them slowly turn on the spot.

With the investigation in the previous exercise, you will have seen that the astronaut actor is being created and assigned to a variable, which is then never used. The variable is essentially discarded in our program. This is not a problem: The astronaut actors remain in the game, because they are held in the graphics world, and we can later get them back from there.

Let us prepare our task by initially rotating every astronaut to a different value, so that they are not all facing the same way.

We can now make all astronauts slowly turn by calling the turn method on each actor in every step of our main loop. To do this, we first need to get access to our astronauts again. Luckily, this is quite easy: the graphics world maintains a list of all actors in the world, and the strype.graphics library includes a function called get_actors() that can be used to get access to this list. We could, for example, get a list of all actors by simply writing

The function has an optional parameter to provide a tag. If a tag is provided, only actors tagged with this tag will be returned. If you check the line where we created the astronauts, you will see that we used the tag "astronaut" for each of our astronaut actors, so we can now use this in our function call:

This call will give us a list of all astronaut actors.

Your astronauts should now be slowly turning while they are floating in space. One last thing that we will add is to make them all re-appear on the surface of the planet after the rocket has landed.

When you run your program, you will notice that the 10 astronauts all appear at once. This is because the for loop is so quick that we see them all appear at essentially the same time. To make this visually more interesting, we can slow down the execution of this for loop, using the pace function, to make the astronauts appear more slowly, one after the other.

A copy of the project with these changes implemented is in the book projects as space-rescue-v2.

With this series of exercises, we have seen how the graphics world uses lists to work with the actors and how we can use these lists to deal with more than one actor at a time. Again, lists are useful here to process a collection of items.

There are, however, a couple of topics that we have glossed over, and which we should discuss in more detail now.

In our project, we have a sound object. We can get the list of samples that makes up this sound by using the sound’s get_samples method.

The first experiment we can do is to reverse the sound to play it backwards. We can do this by reversing our samples list – a first attempt might look like this:

As the comment in the code snippet says: this does not work. The reason for this is that the get_samples() method gives us a copy of the sound’s samples. So by reversing the list, we are not changing the original sound.

We can fix this problem by creating a new sound from the reversed sample list and then playing the new sound:

We see here that we can create a sound, using the Sound class’s constructor (writing the class name Sound with a parameter list), and providing the list of samples as the parameter.

In the following sections, we will do a series of exercises where we manipulate sounds. You could continue using the sound sample provided in our project, but it will be much more fun if you do the exercises with your own sounds. Therefore, we will first discuss how you can record and use your own sounds.

Many programs are available for recording and saving sounds, and several of them are free to use. We will use Audacity here for our screenshots (available from https://www.audacityteam.org). Audacity is a good choice because it is available for different operating systems, is very flexible, free and quite easy to use. There are many other sound editing programs out there, however, so feel free to use one of your choice.

Figure 7.2 shows the interface of Audacity. You see tools for recording and playback and various edit operations, and a wave form display of the recorded sound (the blue graph).

When you record sounds, you often have a delay at the beginning and end of the recording (the straight horizontal line at the beginning and the end of the graph). If we use the sound like this, it will appear to play with a slight delay, because it will play the initial silence as well. Thus, we should trim the sound. "Trimming" means removing the unwanted parts at the beginning and end of the sound recording. You can usually do this in sound editing programs by selecting and then deleting the segment.

Once you are happy with your sound, we are ready to save it to disk.

Sound files can be saved in many different formats and in different encodings, and this can get quite confusing very quickly.

Strype can use sounds saved in WAV, AIFF, AU and MP3 formats. Some of these formats, however, are what is known as “envelope formats” - they can contain different encodings, and not all of them may be playable.

A safe option for saving sound effects is to use the "WAV" format and a “signed 16 bit PCM” encoding. This is the safest format to ensure playback in many different systems. In our case, you should also ensure to save the sound in "mono" (not "stereo"), as this is needed to work with the sample list of the sound. (We could convert the sound from stereo to mono in our Python code, but we may as well do it here.) The sample rate you use is less important, as Strype will by default convert the sound to its own preferred sample rate.

In many sound recording programs, saving in this specific format is achieved by using an “Export” function, rather than the standard “Save” function. Make sure to save in this format.

We are now ready to make modifications to our sound by modifying the sample list, and then creating a new sound from the new samples.

Let us start by duplicating the sound. We can duplicate a list by using the multiplication operator: *. For example:

will duplicate the list so that it contains its elements twice. The list then is:

We can also use the plus operator to append one list to the end of another:

Let us experiment with this. Write some test code for the exercises below.

An effect that is often used as part of music is to play the start of a word repeatedly before playing the whole word. For example, if your original sound is the word "Hello":

then the stutter effect turns it into this:

As you can see, we will have to take a copy of the first part of our sound, multiply it to play it several times, and then append the original sound.

Remember that we can use slicing to create a copy of a part of a list. For example samples[:9000] will create a list holding the first 9000 elements of the samples list.

A version of this project with an implementation of these effects is available in the Chapter07 folder as sounds-v2.

Next, we will create a "cartoon voice" sound effect. This effect plays the sound sample at double speed. This has two consequences: the sound will be shorter, and the pitch will be higher. (The pitch is how high or low a voice sounds.)

Looking at our sound sample list, the idea is very simple: we can simply delete every second sample in our list. If we then play the remaining samples at the same frequency, the sound is half the length, and we can observe how this changes the pitch.

Thus, for our program, the obvious question becomes: How do we best create a list that includes only every second element from the original samples?

It turns out, slicing comes to the rescue again.

The slicing operator has a third optional parameter which we have not used yet. A full slice definition with this parameter looks like this:

As we have seen previously, the first two parameters specify the beginning and end of the slice we wish to create. The third parameter is a step size: A step size of 2, for example, will select every second element, a step size of 3 selects every third element, and so on.

Consider, for example, the following code:

This code snippet will select elements from index 2 to index 9, with step size 2. Thus, it will print

To fully understand this, we have to recall some details about lists and slices:

With just one more bit of information, we are ready to solve our problem: We know that we are permitted to leave out the start or end value of a slice. If we leave out the start, the slice starts at the beginning of the list; if we leave out the end value, the slice extends to the end.

The new bit of information is this: When we use a step value in a slice, we are permitted to leave out both the start and the end value. We then select elements at this step interval from the entire list. In other words

has the effect that every_second is a new list which holds every second element from our original list, starting with the first: [1, 3, 5, 7].

Since our original goal in this section was exactly this – creating a list with every second sample – this is now very straightforward.

The next obvious thing to do is the opposite: Playing the sounds more slowly to lower the pitch. Once we have understood the pitch-up idea, it is quite obvious how we can do this: We just duplicate every sample in our list so that it appears twice in succession. In effect, the list [3, 7, 4] would become [3, 3, 7, 7, 4, 4]. If we do this to the samples list, the list is twice as long, the sound plays more slowly, and the pitch lowers.

Unfortunately, in this case, there is no ready-made operation in Python that achieves this in a single statement. As a result, we will have to write a loop that iterates through our original samples list and creates the new list we need.

The concept for this is quite straight forward: We iterate through the list of samples, and for every sample, add it twice to a new list:

We are starting here with an empty list. The append method adds a single element to the end of the list, and we can see that we are doing it twice to duplicate every element.

We could add both elements in a single statement if we make a short 2-element list from our two samples and then attach this list, using the extend method:

We have to be careful here: If we tried to add the [sample, sample] list using the append method, we would not get an error, but it would not do what we intend to do. It would instead add the 2-element list as a single element into our new list, which is not what we need. To add each element separately, we must use the extend method.

There are various other interesting sound effect we can create, now that we have seen how changing the samples list can create a new sound. We will suggest a few at the end of this chapter. Before we do this, however, it would be useful to create a simple interface for the user to more easily activate these effects.