CPSC 217: Introduction to Computer
Science for Multidisciplinary Studies I
Assignment 3: BeatHero
Weight: 7%
Collaboration
Discussing the assignment requirements with others is a reasonable thing to do, and a good way to learn.
However, the work you hand in must be yours and yours alone. This is essential for you to benefit from the
learning experience, and for you to be graded fairly. Handing in work that is not your original work, but is
represented as such, is plagiarism. Penalties are outlined in the university calendar. A common first penalty is an F
on a plagiarized assignment. Here are some tips to avoid plagiarism in your programming assignments.
1. Cite all sources of code that you hand in that are not your original work using comments in your program,
including the complete URL. For example, if you find and use code found on a website, include a comment
that says:
# The following code is from https://www.quackit.com/python/tutorial/python_hello_world.cfm.
2. Citing sources avoids accusations of plagiarism and penalties for academic misconduct. However, you may
still get a low grade if you submit code that is not primarily developed by yourself. Cited material should
never be used to complete core assignment specifications. Before submitting, you can and should verify any
code you are concerned about with your instructor/TA.
3. Discuss and share ideas with other programmers as much as you like, but make sure that when you write your
code it is your own. A good rule of thumb is to wait twenty minutes after talking with somebody before
writing your code.
4. Collaborative coding is strictly prohibited. Discussing anything beyond assignment requirements and ideas is a
strictly forbidden form of collaboration. This includes sharing code, discussing code itself, or modelling code
after another student's algorithm. You cannot use (even with citation) another student’s code.
5. Using a generative AI tool, such as Copilot or ChatGPT, to assist you in completing assignments is acceptable in
limited circumstances, with attribution. For example, if your assignment is to write a Tic-Tac-Toe program, you
might ask ChatGPT about a small part of that task, such as “How do I convert a string to an integer in
Python?”. You cannot ask for such a tool to do the entire assignment. For example, asking ChatGPT “How do I
write Tic-Tac-Toe in Python?” is unacceptable. If you use a tool such as this, indicate with comments which
parts of your code you asked the generative AI tool about. Keep in mind that when you write your exams, you
will not have access to these tools, so it would be wise not to rely on them too much.
6. Making your code available, even passively, for others to copy, or potentially copy, is also plagiarism.
7. We will be looking for plagiarism in all code submissions, possibly using automated software designed for the
task.
8. Remember, if you are having trouble with an assignment, it is always better to go to your TA and/or instructor
to get help than it is to plagiarize.
Late Penalty
You will have a total of five grace days per semester (across all assignments). After that, late assignments will not
be accepted without a documented university-approved excuse.
Goal
Practice using lists, tuples and dictionaries while creating a game.
Technology
Python 3, SimpleGame Package
Submission Instructions
This assignment requires you to write a computer program using Python. Use the Assignment 3 drop
box in D2L to submit your Python file. You can submit multiple times over the top of a previous
submission. Your assignment must be executable with Python version 3.9.0+. You must use the
SimpleGame library, which contains beatHeroStarter.py code to get you started. You are allowed to
import libraries taught in class, such as random and math. Do not import any other libraries to complete
this assignment.
Upload CPSC217W24A3-Name.py (e.g. CPSC217W24A3-MichelleCheatham.py)
If using your own images, sounds, or music, zip your .py file with the folders containing all the media
associated with your project.
Description
Game Overview
This game, BeatHero, was inspired by the Beat Saber Virtual Reality game. Our game is much simpler,
and you can play it on your computer using your keyboard. Watch the video in the assignment Dropbox
to get a better idea of how the game is supposed to be played (seriously, stop reading here and watch
the video before moving on!)
In our version, when the game starts, the soundtrack starts and beats start falling down your screen, at
first slowly and a few at a time, but as beats move down the zones, they speed up and tests the limits of
your dexterity. Your goal is to score as much as possible before time runs out. Each beat is represented
by an arrow. To score a point, you’ll need to press the arrow key on your keyboard in the direction
noted by the beat arrow before it hits the bottom of the screen. With multiple beats on your screen, you
must always aim for the lowest one.
Game Structure
Before the Game
When the game is run, the starting screen appears. As BeatHero is a real-time game, this step assures
that the player is ready to play before the game starts. The game will only start when the player presses
the space bar.
During the Game
Once the game starts, at the same time, the music track is played, the countdown timer starts, and
beats start falling down the screen in three different streams. The screen is divided into three horizontal
zones. When a beat enters a zone (including the first one): it randomly rotates, changes colors, speeds
up, and increases in points awarded for getting it correct. The zones from top to bottom are orange,
pink and blue. When the player presses an arrow key, a representation of that key is shown on the
screen. Each time the player correctly presses an arrow key in sync with the direction of the lowest beat
on the screen, the beat turns green with a score number beside it, shortly disappears, and the player is
awarded the appropriate number of points (1 for the orange zone, 2 for pink and 3 for blue); we refer to
this as a hit. If the player doesn’t press the correct arrow key, or the beat reaches the bottom of the
screen before any key is pressed, the beat lights up red and disappears; we refer to this as a miss.
After the Game
Once the timer hits 0, the game ends. At this stage, all the beats are removed from the screen, and no
more points will be awarded. The final score is shown on the screen.
SimpleGame
To program BeatHero, you will be using a game engine called SimpleGame which is based on PyGame
and PyGameZero! You can download it here. You will have access to all the documentation on how
SimpleGame works and how to install it. We also provide you with a sample code as a starting point for
your game. After you press the space key on your keyboard, the music starts, and a single beat pointing
to the right falls down the screen. You can write code inside any of the provided functions in this file, but
you will still need to add additional functions.
The SimpleGame package comes with a module named simplegame. All functions available through the
module are listed on here. Before beginning to code, carefully read the documentation for each
SimpleGame function (docstrings) to understand what is available to you. You are only allowed to use
the capabilities of this module for this assignment. Additionally, in your IDE, if you hover over a function
name, you will see its description, parameters (if any) and return value (if any).
In the starter code, you’ll notice three functions (update, draw, and on_key_down) that are called
internally. This means there’s no need for you to call these functions anywhere in your code, as they will
automatically be called by the game engine at the appropriate times.
update()
Like many other game engines, SimpleGame uses a game loop, which is called 60 times per second. The
60 fps (frames per second) allows the game to be updated constantly, to maintain a smooth gameplay
which is very fundamental for real-time games. In your starter code, inside the update() function, we
have provided a frameCounter which you can use to calculate the time that has passed between
different actions.
This is where you should code your game logic, such as animating/moving game elements, updating
scores, checking game conditions, etc.
draw()
This function is called every time something changes on your screen, e.g. a beat moves down by a few
pixels. Similar to simplegraphics, the (0, 0) coordinates are at the top-left of the screen and the order in
which you draw your game element matters. If you put any game logic inside this function, it will
considerably affect your game speed, even making it laggy.
Except for loops and conditions, your code should only use this function for drawing on the screen. The
drawing functions available through SimpleGame are draw_background_image(), draw_element(), and
draw_text_on_screen(). Note that you cannot draw an element before first creating it.
on_key_down()
This function is an event handler that gets called anytime a key on your keyboard is pressed. The integer
value representing the key is passed to the get_key_pressed() function from the simplegame module
and stored in the key_pressed variable inside this function. You only need to compare this value to see if
it’s a desired key, and if not, you may ignore it. Try printing the key_pressed variable and see what it
shows when you press different keys on your keyboard.
Functions inside the simplegame Module
Here, we quickly review some of the functions that are available to you through the simplegame
Module.
Creating, Drawing and Rotating Movable Elements
To place any image on the screen, you first need to call the create_element() function. You will pass the
name of the image file (without the .png extension) along with the starting position and it will return a
dictionary with a single key that contains the id for that specific element. You are encouraged to add
other key-values to this dictionary to control your elements. Note that creating an element won’t make
it appear on the screen. To do that, you must use draw_element(). To rotate the element clockwise, you
must use rotate_by().
Look inside the images folder to find a variety of beats, arrows, backgrounds, and many more.

When generating beats, you must randomly rotate the image by 0, **, 180 or 270 degrees, and
randomly choose the stream (1,2,3) the beat falls through. Stream is the path in which the beat falls
straight down the screen. You need to keep track of which stream the beat belongs to have it move
down the screen. There is quite a lot of information that is associated with every beat, so make sure you
take advantage of these dictionaries. Here are some ideas for keys you can add to your element
dictionary:
• stream / column (1,2,3): Which stream the beat should appear and move to.
• zone (‘orange’, ‘pink’, ‘blue’): Which zone the beat is falling through currently.
• moving / active (True/False): Once a key is pressed, the lowest beat must stop moving and
instead momentarily show whether the player hit the correct or wrong key.
• scored / status ('hit', 'miss', 'superhit', etc.): Keeping track of whether the beat was scored or
not before removing the key permanently.
• speed (‘slow’, ‘medium’,’fast’): Keeping track of speed of the beat
• direction ('left', 'right', 'up', 'down'): This will be helpful to see if the correct key was pressed.
You can also create a dictionary to represent zones with relevant characteristics, such as for zone A:
• zone (‘orange’, ‘pink’, ‘blue’): The zone this dictionary represents
• speed (‘slow’, ‘medium’,’fast’): Keeping track of speed of the zone
• points (‘+1’, ‘+2’, ‘+3’): Keeping track of points a hit in each zone can score
Retrieving Info from the Game Engine
The following functions allow you to get real-time information about elements on the screen.
get_image() retrieves the string name of the image of the element.
get_position() retrieves the position of an element i.e. x, y coordinates
get_rotation_angle() retrieves the rotation angle of an element, clockwise, from its original orientation
Music and Sound
Music and sound behave differently. A music track is long and looped indefinitely, while a sound clip is
short and only plays once.
Your game must play background music using manage_background_music() function. The music files can
be found under the music folder in your project. When you play a music file, it will loop indefinitely until
you stop or pause it.
Your game must also play sound clips corresponding to hit or missed beats by using play_sound_clip()
function. Some sound files can be found under the sounds folder in your project.
Scheduling Callback for Functions:
Callback functions accept the name of the function that is scheduled to be (a) called after a specified
interval of time using schedule_callback_after() or (b) called repeatedly every specified interval
schedule_callback_every(). If you want to cancel a callback to a function that you already scheduled, you
can call cancel_callback_schedule() at any point. Note that when you pass a function to another one as
an argument, it cannot take any parameters, and you need to remove the brackets in front of it. You
must also pass an immutable integer/float for seconds. If you need to change the callback time, you
need to cancel the current one and reschedule a new one. These functions are useful for momentarily
changing the image of an element or for actions that happen repeatedly. You are not required to use
these, as you can achieve the same using the frameCounter inside your update() function.
Getting started
1. Unzip the Provided File
- Download the ZIP file from here for this assignment.
- Extract its contents to a preferred folder on your computer.
2. Setting Up Your Environment with PyCharm
- Open PyCharm and navigate to `File` > `Open...`, then select the directory where you extracted the
assignment files.
- In Pycharm, locate the terminal window (usually found at the bottom). You might need to go to
View -> Tool Windows -> Terminal to get the terminal to appear.
3. Install Required Package
- In the PyCharm terminal, type the following command and press Enter:
- pip install SimpleGame-2.6.7.tar.gz (the same as the filename in your BeatHero directory)
- This command installs the necessary SimpleGame package, which contains the module with the
functions and utilities you'll need to develop this game.
- Open beatHeroStarter.py file and run it.
Suggested Algorithm
1. Create all the visual elements you plan to have in your game (except for the beats), using width
and length of the window to determine the positioning of each element.
2. Draw the elements associated with each stage of the game (before, during, and after) and any
text that you’d want to show on the screen in your draw() function.
3. Set up the timer counting down and set the condition for when the timer reaches 0 seconds.
By this point, you will be able to run your game, and go through all three stages.
4. Change the ‘generate_beat()’ function in the starter code so that it creates a beat with a random
orientation, and assign it to a random stream. After creating a beat, add it to ‘beatList’.
5. During the game, repeatedly generate random beats. (e.g. every second)
6. In your draw() function, draw every member of the ‘beatList’ inside the during the game section.
7. Using the same logic, in update(), have the beats move down a couple of pixels on each frame.
The falling beats should not overlap with widgets at the top of the screen (e.g. score and timer).
By this point, you will see new beats at the interval you specified, and they all fall down.
8. Create a function that determines which beat is the lowest beat on the screen.
9. Write logic that anytime an arrow key is pressed, it compares the lowest beat’s direction with
the key_pressed.
10. Write the logic for updating the lowest beat’s status after an arrow key is pressed:
a. Stop its movement.
b. According to whether it was a hit/miss, write a function that
i. Change its image.
ii. Play the corresponding sound clip.
iii. If a hit, display how many points they scored beside the beat (+1, +2, +3 for
zones A, B, C, respectively)
iv. Make the beat disappear after the user is able to see them (0.**0.3 seconds).
v. Update the total score.
11. Inside update(), write a logic that will keep track of any beat that reaches the end of the screen,
and use the same miss function for it.
By this point, beats will be falling down the screen on three different streams, and you’re able
to play the game.
12. Write logic that calculates the specific y-position representing a threshold between the zones
(zone A to zone B and from zone B to zone C). Each beat should start at the top of zone A -
orange. For each zone:
a. A function for changing the color (changes images) of the beat when entering a new
zone.
b. A function for speeding up the rate at which beats are generated and are moving down
the screen as the beat enters a new zone.
c. A function that increases the number of points added to the score when the beat enters
a new zone.
13. Update the score text during the game on the top and after the game.
Requirement Checklist
• You must use lists, dictionaries, and tuples in your program.
• Play background music.
• Play 2 different sound clips to indicate hit/miss beats.
• 3 different streams of beats flowing from top to the bottom of the screen.
• A random stream for each beat.
• When entering a new zone:
a. random rotation
b. beat color according to the zone
c. speed of the movement increases
d. point of value increases
• 5 different arrow images used for beats (orange, pink, blue, hit, miss).
You are not allowed to use more than 5 arrow images in your code.
• Text/image with number of points added to score beside a hit beat. No text beside a missed
beat.
• A countdown timer visible on the screen which would end the game when it reaches zero.
• Real-time score of the player during the game, and the final score when the game ends.
• A visual representation of the keys pressed by the player during the game.
Optional
You are not required to use our images, but you’re strictly prohibited from using 4 different images for
up, down, left and right as you need to handle that in your code by rotating the same image. If you use
different images, music and sound clips, make sure they fulfill the criteria mentioned in the SimpleGame
documentation. If you're adding your own arrows, ensure that all arrow images have the same angle,
rather than having separate images for each rotation. You are only allowed to use png images and wav
music or sounds. Make sure to use only lowercase names for the files and add them to their
corresponding folders.
Grading
The assignment will be given a plus/minus letter grade, with the grade based on the program’s
level of functionality and conformance to the specifications. Fully meeting the specified
requirements will result in an A. An A+ may be awarded to particularly impressive submissions.
As a reminder, the University of Calgary assigns the following meaning to letter grades:
A: Excellent – Superior performance showing a comprehensive understanding of the subject
matter
B: Good – Clearly above average performance with generally complete knowledge of the
subject matter
C: Satisfactory – Basic understanding of the subject matter
D: Minimal Pass – Marginal performance; Generally insufficient preparation for subsequent
courses in the same subject
F: Fail – Unsatisfactory performance
How to get an A+
For students wanting to do extra work to receive an A+, you can do one of the following options. Note
that because this is optional, TAs and instructors will not be able to help you figure out how to achieve
things in this section (either in implementation or debugging).
- Have a second play mode in which the player loses if they miss three beats, and they win if they
last the timer. The player must be able to choose the game mode before starting the game.
- Add 3 randomly selected Super-Beat (find a new image for it), where if the player hits the right
key for it, all beats currently on the screen disappear (and you get corresponding points).
- Add at least two of the following: (1) Extra control elements to the screen e.g. controlling the
starting speed of beats, (2) Extra capabilities to the already existing elements e.g. the timer
changes color from green to red gradually as the player nears the end of the game.

請加QQ：99515681  郵箱：99515681@qq.com   WX：codehelp