4. Exercises: Modules of the End Times¶

These are the last exercises of the course. Think about that! But preferably only after you've thought about the exercises themselves. The topics today cover files and Python modules. The project-related exercises also offer quite fat chunks of code for the couse project.

Learning Goals¶

After this exercise you should be somewhat familiar with manipulating files. You'll also know quite a more bit about using modules, and also know how to make your own code work as a module. You'll also become familiar with the libary (or libraries) designed for the course project.

Example¶

As we promised in the material, this example covers the sweeperlib

library

that was made specifically for the course project. The example mostly covers how

handlers

behave with this library. It also continues from a couple of exercises in the sense that we're finally showing you how to implement movement using unit vectors.

Running the example requires Pyglet, which can be installed with

pip install pyglet

If the example does not work after this and you get any kind of GLException, install an older version of Pyglet:

pip install "pyglet<2.0.0"

Task Description¶

It would be fun to make an entire game prototype but that would involve a lot of things that are not necessary for this course. Instead, we're just going to make a simple, controllable game object. Let's set our goal to making a character that moves on its own and is animated, and it changes its direction when the player clicks somewhere on the screen. Let's also say that the character's movement speed isn't fixed, but instead accelerates upward from zero whenever the target point changes.

Solution¶

sweeperlib.py

The very first thing is to make something show up on the screen. This is where sweeperlib comes in to help. Its core principles are pretty much the same as the library we described in the material: the program's main loop runs Somewhere Else (tm), and the game logic itself is implemented in handler functions. This time around we just don't have interface components to attach our handlers to. If we take a look at sweeperlib, it can attach handlers of four types:

mouse handler, which handles mouse clicks
keyboard handler, which handles key presses
draw handler, which handles draw
event
interval handler, which is called repeatedly at given intervals

At minimum a game needs to have a draw handler in order for anything to be shown on the screen. Whereas our guilib did the drawing for us, this time we need to do it ourselves. This is because sweeperlib doesn't define premade game objects the same way guilib defines user interface components. The main responsibility of the draw handler is to draw each game object to a position on the screen tht matches its position in the game's logic. However, before we can actually draw anything we need to load some graphics. This step is not needed in minestomping because the library already contains a function to load the sprites that we've provided. Likewise there is no need to import pyglet in your own program, and specifically in this page's exercises you are not allowed to do that. For this example we need to create a separate function for loading two sprites (from the zip below) from the given

path

cross.zip

import pyglet
import sweeperlib

WIDTH = 800
HEIGHT = 600

def load_sprites(path):
    pyglet.resource.path = [path]
    sprites = {
        "0": pyglet.resource.image("plus_1.png"),
        "1": pyglet.resource.image("plus_2.png")
    }
    sweeperlib.graphics["images"] = sprites

We didn't choose the sprite

keys

arbitrarily - the reason will be revealed later. We also need the actual draw handler, which we'll implement by following the example at the end of sweeperlib - the whole process has been described in detail in the library's

docstrings

. We'll draw our sprite to 100, 100.

def draw_game():
    sweeperlib.clear_window()
    sweeperlib.draw_background()
    sweeperlib.begin_sprite_draw()
    sweeperlib.prepare_sprite("0", 100, 100)
    sweeperlib.draw_sprites()

When these two functions are used in initializing the game and in the main program, we can see a prett plus sign on the screen. The handlers aren't attached to interface elements this time. Instead they're attached directly to the library itself by functions that exist for this purpose.

def start_game():
    sweeperlib.create_window(WIDTH, HEIGHT)
    sweeperlib.set_draw_handler(draw_game)
    sweeperlib.start()
    
if __name__ == "__main__":
    load_sprites("sprites")
    start_game()

The next step is to create some interactivity. We can start by making the game recognize the user's clicks, and react to them by teleporing the character to the spot. At this point we'll employ a familiar

dictionary

. As

handlers

still have the same issue we uncovered in the material, we cannot influence what arguments they receive. In other words, just like in the material, the game's state should be put into a

global

dictionary. We'll call it state, and place the dictionary that represents our character inside it with the "player"

key

state = {
    "player": {
        "x": 0,
        "y": 0,
        "heading": 0,
        "speed": 0
    }
}

The dictionary contains empty values of the correct type for each key. Once again the purpose is to show at a glance what attributes the game's characters have. Setting the values (to random position) is done in a separate create_player function.

def create_player():
    state["player"] = {
        "x": random.randint(0, WIDTH - 1),
        "y": random.randint(0, HEIGHT - 1),
        "heading": 0,
        "speed": 0
    }

Now that we have an object that has a position in the game logic, we can make a mouse handler that changes the position. The handler has four

parameters

although we only need the first two for x and y coordinates. The idea is the same as before: the handler changes values of the dictionary attached to the "player" key in the state dictionary. This makes the changes take effect everywhere this dictionary is used.

def handle_mouse(x, y, button, modifiers):
    state["player"]["x"] = x
    state["player"]["y"] = y

We also need to change the draw handler to draw the character where it actually is:

def draw_game():
    sweeperlib.clear_window()
    sweeperlib.draw_background()
    sweeperlib.begin_sprite_draw()
    sweeperlib.prepare_sprite("0", state["player"]["x"], state["player"]["y"])
    sweeperlib.draw_sprites()

And finally use the new functions when starting the game:

def start_game():
    create_player()
    sweeperlib.create_window(WIDTH, HEIGHT)
    sweeperlib.set_draw_handler(draw_game)
    sweeperlib.set_mouse_handler(handle_mouse)
    sweeperlib.start()

Basically this is enough information you need about handlers to implement a minesweeper. Majority of the game's logic will happen in handlers, and the functions they call. That said, this example doesn't quite yet match the specification, so we'll work on it a bit more. We wanted the character to accelerate towards the chosen point instead of teleporting to it. Because the character already has speed and heading, we need a click handler that changes the heading and sets the speed to zero. We also need to add acceleration as one attribute of the character.

The mouse handler becomes:

def handle_mouse(x, y, button, modifiers):
    set_heading(state["player"], x, y)
    state["player"]["speed"] = 0

Setting the heading is best done in its own funcion because it sounds like something that would be useful in more than just this one context. There might even be more than one object in the game in the future! At this point we need to recall some basic trigonometry: if we know the base and height of a triangle, the angle is obtained with arctan, which has its own function in the math module. We just need to know that atan isn't good enough because it doesn't handle the signs of x and y separately - atan2 does.

def set_heading(character, target_x, target_y):
    distance_x = target_x - character["x"]
    distance_y = target_y - character["y"]
    character["heading"] = math.degrees(math.atan2(distance_y, distance_x))

We don't have any real reason to convert angles to degrees here since they're never shown to players. We just did so because it makes the code a bit easier to digest. Especially if the program needs to be debugged at some point, and we need to investigate the headings of objects, degrees come in handy. Anyway, the player can now control the character. It just doesn't quite move yet. For this we need a third handler, one that updates the game state continuously, or approximately 60 times per second. The documentation of sweeperlib tells us that such a handler receives one argument: time elapsed since the last time it was called.

def update_game(elapsed):
    state["player"]["speed"] += state["player"]["accel"]
    update_position(state["player"])

You can find the update_position function called here from your own exercise solution. This solution relies on the game actually achieving 60 frames per second. If the game didn't achieve this, the game logic would slow down. A more correct solution would be to use the function's parameter so that all time-dependent values are multiplied by elapsed * 60 (which is exactly 1 if the game runs at 60 fps). We'll leave the code as is however, because it's a bit easier to read. When this handler is registered in the start_game function, we've achieved a controllable object.

def start_game():
    create_player()
    sweeperlib.create_window(WIDTH, HEIGHT)
    sweeperlib.set_draw_handler(draw_game)
    sweeperlib.set_mouse_handler(handle_mouse)
    sweeperlib.set_interval_handler(update_game)
    sweeperlib.start()

As a last curiosity, we'll show you how to do a two-frame animation. In order to do this, we need to add another key to the character dictionary. The value of this key indicates which sprite is shown currently. The keys for the sprites were "0" and "1" when we loaded them. In other words this key will always be inside [0, 2). We also need a constant to adjust the animation speed - a picture blinking 60 times per second is not pleasant to look at. With a value of 0.1 the sprite only changes 6 times per second.

ANIM_SPEED = 0.1

state = {
    "player": {
        "x": 0,
        "y": 0,
        "heading": 0,
        "speed": 0,
        "accel": 0,
        "sprite": 0
    }
}

Because we had the foresight to name the sprites "0" and "1" we can do the swapping with mathemagics. This is added to the update_game function. At each update the value of the sprite key is incremented by the animation speed constant, so that it takes 10 cycles from zero to one, and another 10 from one to two. Because there is no sprite number 2, we can wrap the cycling around to zero with modulo 2.

def update_game(elapsed):
    state["player"]["speed"] += state["player"]["accel"]
    state["player"]["sprite"] = (state["player"]["sprite"] + ANIM_SPEED) % 2
    update_position(state["player"])

Again our game would be more stable if we multiplied the animation speed by elapsed * 60. The drawing handler also needs a change where it picks the sprite to draw from the dictionary. Because the value is a float from range [0, 2), it needs to be converted to an integer. The keys in the graphics dictionary are

strings

, but we peek inside the library it converts the sprite argument to a string - so we can give it integers. With this we've created a beautiful(?) animation. You can gaze at the result in amazement by downloading the program.

crossgame.py

import math
import random
import pyglet
import sweeperlib

WIDTH = 800
HEIGHT = 600
ANIM_SPEED = 0.1

state = {
    "player": {
        "x": 40,
        "y": 40,
        "heading": 0,
        "speed": 0,
        "accel": 0,
        "sprite": 0
    }
}

def load_sprites(path):
    pyglet.resource.path = [path]
    sprites = {
        "0": pyglet.resource.image("plus_1.png"),
        "1": pyglet.resource.image("plus_2.png")
    }
    sweeperlib.graphics["images"] = sprites
    
def create_player():
    state["player"] = {
        "x": random.randint(0, WIDTH - 1),
        "y": random.randint(0, HEIGHT - 1),
        "heading": 0,
        "speed": 0,
        "accel": 0.2,
        "sprite": 0
    }

def convert_to_xy(a, r):
    x = int(round(math.cos(a) * r))
    y = int(round(math.sin(a) * r))
    return x, y    
    
def set_heading(character, target_x, target_y):
    distance_x = target_x - character["x"]
    distance_y = target_y - character["y"]
    character["heading"] = math.degrees(math.atan2(distance_y, distance_x))
    
def update_position(char):
    dx, dy = convert_to_xy(math.radians(char["heading"]), char["speed"])
    char["x"] += dx
    char["y"] += dy

def handle_mouse(x, y, button, modifiers):
    set_heading(state["player"], x, y)
    state["player"]["speed"] = 0
    print(state["player"])

def update_game(elapsed):
    state["player"]["speed"] += state["player"]["accel"]
    state["player"]["sprite"] = (state["player"]["sprite"] + ANIM_SPEED) % 2
    update_position(state["player"])
    
def draw_game():
    sweeperlib.clear_window()
    sweeperlib.draw_background()
    sweeperlib.begin_sprite_draw()
    sweeperlib.prepare_sprite(int(state["player"]["sprite"]), state["player"]["x"], state["player"]["y"])
    sweeperlib.draw_sprites()
    
def start_game():
    create_player()
    sweeperlib.create_window(WIDTH, HEIGHT)
    sweeperlib.set_draw_handler(draw_game)
    sweeperlib.set_mouse_handler(handle_mouse)
    sweeperlib.set_interval_handler(update_game)
    sweeperlib.start()
    
if __name__ == "__main__":
    load_sprites("sprites")
    start_game()

Common Exercises¶

As usual everyone needs to do these

Warmup Exercise¶

Spiraling Out of a File¶

This exercise continues the development of our a-spiraling code from last exercises. A new feature is to be added: it can draw by reading instructions from a file that contains multiple spirals. Each line in the file has the parameters of one spiral.

Learning goals: Reading from files, and converting file contents to variables.

Goal: A program that reads drawing instructions from a file and uses them along with the existing draw function to draw spirals.

Introduction:

You'll need to draw_spiral function from last week's spiral exercise. Copy it to your code file.

Function specification: draw_from_file

Parameters
:

filename to read (string)

The function must open a

file

and read its lines that describe spirals. Each line has values in the same order as the draw_spiral function's parameters separated by commas:

spiral's color (color value - either a color name or a hexadecimal color code)
number of arcs to draw (integer)
spiral's initial radius (integer)
radius growth (float)
pen weight (integer)

The function needs to read these values from each line, convert them to correct types, and then call the draw_spiral function with them. Although pen weight is an optional argument, it is found on every line in the file - you can safely assume that each line will have 5 values.

In general you can freely assume that there are no errors in the file.

Use Examples:

Below is one example of a file that your function should be able to read. There's also a familiar picture that's been drawn based on this file.

spiral.txt

black,20,10,3,1
red,10,20,4,3
blue,10,-20,-4,3

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Main Exercises¶

Dunkin' Donkeygotchi¶

Some might still remember Tamagotchis or other virtual pets from way past. In this exercise you will implement your own virtual pet - a virtual donkey, of course.

This exercise teaches you how to work with a program made of more than one file, and with code made by someone else. We've included some of the donkeygotchi's modules. Your task is to finish the job by filling gaps in the main program and by creating the user interface module. The internal logic of the bit donkey has been already defined, along with a bunch of constants.

Learning goals: Reading code written by other people and completing it. Implementing your own

modules

. Using

dictionaries

and

constants

in code.

Goal: Make a user interface module for an otherwise functioning donkeygotchi.

Introduction:

This exercise uses two completed

code files

and one half-finished file. The files have the following roles:

main.py: Main program module, functions as the program's "entrance" and implements the main loop that glues the program's logic together. This file has some placeholders marked with question marks that you have to fill in.
donkeydefs.py: Contains predefined
constants
(like Python's math.pi) that can be used in other modules of the program.
donkeylogic.py: The engine of the program that creates and manages data.

The code files can be found at the end under "Resources"

Unfinished Module: main.py

The program cannot be ran before the placeholders in main.py have been filled in. What you need to do for each can be found out by looking at the donkeylogic and donkeydefs modules.

Module Specification: donkeyinterface.py

Docstring
:

"Defines the donkeygothi's user interface."

Functions
:

show_state: (details below)
prompt_choice: (details below)

1st function specification: show_state

Parameters
:

donkey's state in a data structure (dictionary)

This function prints the donkey's state, i.e. the values of age, money, satiation, happiness and energy. In addition, if the donkey has retired, a separate print is done to indicate this. The exact strings to use can be found from the examples at the end.

2nd function specification: prompt_choice

Parameters
:

donkey's state in a data structure (dictionary)

Returns
:

a valid input made by the user (string)

The function prints the available choices - based on the donkey's state - once, and then proceeds to prompt the user to make a choice until they give an input that is currently valid. If the donkey is not retired, the valid inputs can be found from the CHOICES list in the donkeydefs module; if the donkey is retired, valid inputs are in the RETIRED_CHOICES list. These constants should be used for both printing the available choices, and validating inputs. All strings to use in prompts and prints can be found from the examples.

Use Examples:

The donkey is 96 years old and has 0 eur.
Satiation: 5
Happiness: 5
Energy: 5
Choices: q, f, w, t
Input next choice: q

The donkey is 96 years old and has 0 eur.
Satiation: 5
Happiness: 5
Energy: 5
Choices: q, f, w, t
Input next choice: Z
Invalid input!
Input next choice: ???
Invalid input!
Input next choice: w
The donkey is 97 years old and has 1 eur.
Satiation: 5
Happiness: 5
Energy: 5
Choices: q, f, w, t
Input next choice:

The donkey is 100 years old and has 12 eur.
Satiation: 6
Happiness: 9
Energy: 2
The donkey has retired.
Choices: q, r
Input next choice: X
Invalid input!
Input next choice: f
Invalid input!
Input next choice: t
Invalid input!
Input next choice: r
The donkey is 0 years old and has 0 eur.
Satiation: 5
Happiness: 5
Energy: 5
Choices: q, f, w, t
Input next choice:

Resources:

Download these files from below.

donkeylogic.py

"""
Defines the donkeygotchi's internal logic
"""
import donkeydefs as defs

def init():
    """
    Initializes donkey data by creating a new dictionary with initial values for
    all keys, and returns it.
    """
    donkeydata = {
        "SATIATION": defs.INITIAL,
        "HAPPINESS": defs.INITIAL,
        "ENERGY": defs.INITIAL,
        "AGE": 0,
        "MONEY": 0,
        "RETIRED": False,
    }
    return donkeydata

def _age(donkeydata):
    """
    Ages the donkey and - if needed - puts it in retirement. Meant only for 
    internal use in this module.
    """
    donkeydata["AGE"] += 1
    
    if donkeydata["AGE"] == defs.RETIREMENT_AGE:
        donkeydata["RETIRED"] = True

def _update_states(donkeydata):
    """
    Changes the donkey's state as time passes, and puts the donkey in retirement
    if needed. Meant only for internal use in this module.
    """
    if donkeydata["AGE"] % 2 == 0:
        if donkeydata["SATIATION"] > 6 and donkeydata["ENERGY"] < defs.MAX_STATE:
            donkeydata["ENERGY"] += 1
        donkeydata["SATIATION"] -= 1
    if donkeydata["AGE"] % 3 == 0:
        donkeydata["HAPPINESS"] -= 1
    
    if donkeydata["SATIATION"] <= 0 or donkeydata["HAPPINESS"] <= 0 or donkeydata["ENERGY"] <= 0:
        donkeydata["RETIRED"] = True

def feed(donkeydata):
    """
    Feeds the donkey, i.e. raises its satiation, if it isn't at the maximum yet.
    """
    _age(donkeydata)
    _update_states(donkeydata)
    if donkeydata["SATIATION"] < defs.MAX_STATE:
        donkeydata["SATIATION"] += 1
    
def tickle(donkeydata):
    """
    Tickles the donkey, i.e. raises its happiness, it it isn't at the maximum yet.
    """
    _age(donkeydata)
    _update_states(donkeydata)
    if donkeydata["HAPPINESS"] < defs.MAX_STATE:
        donkeydata["HAPPINESS"] += 1

def work(donkeydata):
    """
    Makes the donkey work by spending its energy in return for money.
    """
    _age(donkeydata)
    donkeydata["ENERGY"] -= 1
    donkeydata["MONEY"] += 1
    _update_states(donkeydata)

donkeydefs.py

"""
Defines the variables that are used in the donkeygotchi.
"""

# input choices
QUIT = "q"
FEED = "f"
TICKLE = "t"
WORK = "w"
CHOICES = [QUIT, FEED, TICKLE, WORK]

RESET = "r"
RETIREMENT_CHOICES = [QUIT, RESET]

# Aasin tilat
INITIAL = 5
RETIREMENT_AGE = 100
MAX_STATE = 10

main.py

import ???
import ???
import ???

def main():
    donkeydata = donkeylogic.???
    
    while True:
        donkeyinterface.show_state(donkeydata)
        choice = donkeyinterface.prompt_choice(donkeydata)
        
        if choice == donkeydefs.QUIT:
            break
        elif choice == donkeydefs.FEED:
            ???
        elif choice ==  donkeydefs.TICKLE:
            ???
        elif choice == donkeydefs.WORK:
            ???
        elif choice == donkeydefs.RESET:
            ???

if __name__ == "__main__":
    ???

return donkeyinterface.py and main.py. You can choose more than one file in the browser's upload dialog by pressing Ctrl down when choosing.

Submit your files here:

Warning: You have not logged in. You cannot answer.

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Course Project Exercises 1¶

Choose one of these. Note that there's only two choices here: minestompers should pick the first one, duck throwers the last one, and others the second one. This is because the spectrum and circuit projects use the same library to create their user interface. These tasks are not required for minimal course completion.

Mine Assignment: Time to Mousey¶

Who would play a text-based terminal minesweeper in the 2000s? This exercise along with the following ones give you a basis that allows you to implement a beautiful Minestomper with real graphics and mouse controls. We've given you a custom library for this purpose, and this exercise starts your journey in getting familiar with it. The topics are application windows and handler functions.

Learning goals: Creating a window. Handling the mouse with sweeperlib. Implementing and using a handler function.

Goal: A program where the mouse handler tells where inside the window mouse was clicked.

Introduction:

This exercise uses the library we made for the Minestomper course project. It helps rather significantly in implementing a graphical interface. Download the library if you don't have it yet and explore it carefully. The library comes with rather extensive docstrings and a short example at the end.

sweeperlib.py

The Minestomper project page also contains some explanations about how to use the library - definitely worth a read at this point. You should also install Pyglet if you haven't already. Furthermore, if you get any kind of GLException when running the code, try to install an older version by typing

pip install "pyglet<2.0.0"

Note that in order to complete this exercise your code does not need to import Pyglet - all interaction with Pyglet is done through sweeperlib. The checking server doesn' even have Pyglet so trying to import in your code causes a ModuleNotFoundError exception. In the course project itself you can do what you want however.

1st Function Specification: handle_mouse

Docstring
:

"""
This function is called when a mouse button is clicked inside the game window.
Prints the position and clicked button of the mouse to the terminal.
"""

Parameters
:

x coordinate of the mouse (integer)
y coordinate of the mouse (integer)
mouse button (integer)
pressed modifier keys (integer - not used in this exercise but needs to be defined in order for the function to be callable)

The function prints its parameers to the terminal (see examples for formatting). The mouse button is an integer where each value corresponds to a different button. You don't need to memorize these values because you can use the sweeperlib constants MOUSE_LEFT, MOUSE_MIDDLE, and MOUSE_RIGHT to know which button was clicked. You can practice dictionaries by making one where these constants are the

keys

and strings "left", "middle", and "right" are their values.

2nd Function Specification: main

Docstring:

"""
Creates a game window and sets a handler for mouse clicks.
Starts the game.
"""

The main function has to create a window using the sweeperlib's create_window function, and set a mouse handler using the set_mouse_handler function. Study how these functions work. You can choose the size of the window freely. Background color doesn't matter because the window is not drawn after being created. At the end the application needs to be started with the start function.

Function Testing:

if __name__ == "__main__":
    main()

Use Examples:

These examples only show what is printed to the terminal.

The left mouse button was pressed at 123, 53
The right mouse button was pressed at 20, 10
The middle mouse button was pressed at 250, 39

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Spectral and Circuit Assignment: Just an Ordinary Window¶

In order to see spectrums and circuits running you need to learn the basics of graphical user interfaces. This is the first exercise in the series. It will teach you how to create a basic interface with a couple of components. A small library will assist you in this quest, allowing you to survive with a few simple function calls.

Learning goals: The basics of creating a use interface window. The basics of the guilib library used in the course project.

Goal: A program that creates an interface window.

Installation: matplotlib

The guilib module requires matplotlib in order to work. You can install it with the pip program by giving this command: pip install matplotlib. Pip is usually included with Python. See pre-exercises if you don't remember how to use it. In some Linuxes and in Mac OS X the command can be pip3 - pip alone installs for Python 2.

Introduction:

The exercises uses the guilib module that is also used in Spectral Matters and Run, Circuit! Run! The library contains functions that allow you to create simple user interfaces. Download the library from the link below and study it carefully. It contains extensive docstrings and an example program at the end.

guilib.py

The first thing you should do is to test the library by running it. If you get a message about a missing DLL, it's very likely this one and you need to install it.

The course project page also gives a short introduction to graphical user interfaces. Should be a worthy read at this point.

Note that you do not need to import either Tkinter or Matplotlib into your own program - everything happens through guilib. These haven't been even installed on the checking server which means you will get ModuleNotFoundError exceptions if you try to return code that imports them.

Finally, create this dictionary into your program, it will contain references to the UI components.

widgets = {
    "textbox": None
}

Because the program is mostly based on handler functions you have no control over what parameters they can have. Therefore the program's state and references to components must be kept

globally available

. The best way to manage that is to collect everything into a dictionary that can be accessed from all functions.

1st Function Specification: print_testline

Docstring
:

"""
Prints a test line into a textbox in the user interface.
"""

When the function is called it writes e.g. "donkeyswings" (doesn't matter, write what you want) to a textbox in the widgets dictionary. Use the library's write_to_textbox function. The message contents don't matter, its purpose is to just show that the UI components have been connected to each correctly.

2nd Function Specification: main

Docstring:

"""
Creates an application window with two buttons on the left and one textbox on
the right. Text can be printed to the box by pressing a button.
"""

The task of the main function is to create the interface components, connect handlers to buttons, and finally start the program. We want a window with two frames: on the left there should be two buttons, and on the right a textbox. The first button should be connected to the print_testline function we just created. The second button's handler is the library's quit function. You can choose the text on the buttons.

When you create the textbox, assign it to the previously defined dictionary.

You need the create_window, create_frame, create_button, and create_textbox functions from the guilib. The examples section shows a screenshot of the completed interface. Exact measurements might differ from your version but the layout must match.

Function Testing:

if __name__ == "__main__":
    main()

Use Examples:

*The layout should look like this. Exact measurements can differ.*

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Duck Assignment: Basics of Box Dragging¶

In order for us to be able to slingshot ducks into the air, the player needs to be able to drag the imaginary string of sling. This assignment introduces the required basics: how dragging things with the mouse works in general. This functionality will be offered by the support library made for this course.

Learning goals: Creating an application window. Dragging on object inside the window.

Goal: Program where the user can drag a box.

Introduction:

In order for

handlers

to conveniently access the box, it should be presented as a

dictionary

at the beginning of the program. Grab the dictionary from below, and put into your code after all the necessarity imports.

box = {
    "x": 200,
    "y": 200,
    "w": 40,
    "h": 40
}

1st Function Specification: handle_drag

Docstring
:

"""
This function is called when the mouse is moved while one of its buttons is
pressed down. Moves a box on the screen the same amount as the cursor moved.
"""

Parameters
:

mouse x coordinate (integer)
mouse y coordinate (integer)
x coordinate change (integer)
y coordinate change (integer)
mouse button (integer)
pressed modifier keys (integer - not relevant, but needs to be defined)

The function must move the box by changing its x and y coordinates by an amount equal to the cursor's movement along each axis. The library calls this function repeatedly while the cursor is moving, and the change of coordinates is given as difference from the cursor's position at the time of the previous call. Using this change information, the box can be made to move based on the cursor's movement (regardless of cursor's actual position).

You know your function works correctly if the box moves without any jumps when the cursor is moved while a button is held down.

2nd Function Specification: draw_box

Docstring:

"""
Draws a box into the application window.
"""

Open sweeperlib.py and read the instructions from the set_draw_handler function's docstring. You can also look at the example at the beginning of his exercise page. The box's position needs to be read from the box dictionary. Use the space character " " as the box's sprite key.

3rd Function Specification: main

Docstring:

"""
Creates an application window and sets handler functions for dragging and
drawing. Starts the application.
"""

The main function needs to create the application window using the create_window function from the library, and set handler functions for events with set_drag_handler and set_draw_handler functions. Check the documentation to see how these work. You can choose the window's size and background color freely. At the very end, this function has to start the application using the start function.

Testing:

if __name__ == "__main__":
    main()

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Course Project Exercises 2¶

Choose on of these. These tasks are not required for minimal course completion.

Mine Assignment: Mine Time¶

Randomness is a rather important aspect in games, and in general important enough to have its own programming tools. This exercise will help you when it's time to generate a mind field in the Minestomper course project. You'll also learn about drawing graphics with game libraries.

Learning goals: Getting familiar with the random module and implementing a suitable randomization for mine placement. The basics of drawing game graphics. Implementing a draw handler with the sweeperlib module.

Goal: A program that places a specified number of mines into random tiles in a field, and shows the result in a game window.

Introduction:

This exercise uses the same sweeperlib module as the previous one. In addition you will need the minestomper graphics package and unpack its contents into a folder of your choice.

Because the draw handler cannot have any parameters, it's not possible to hand the field to it as an argument. Therefore the field needs to be made available to all functions in the program through some other means. In this exercise we'll use a dictionary that holds the game state - this is the best way to do this with our current knowledge. Place the following snippet into your code immediately after imports:

state = {
    "field": []
}

Naturally the empty list will be replaced with a two-dimensional list that represents the field once the program is running. Note that the checker requires your program to have this dictionary.

1st Function Specification: place_mines

Docstring
:

"""
Places N mines to a field in random tiles.
"""

Parameters
:

field to mine (2-dimensional
list
)
list of available tiles (list of coordinate pair
tuples
)
number of mines to place (integer)

The function chooses N coordinate pairs from the list of available tiles and places a mine into each of the selected tiles in the field (mine is marked with "x"). This can be done in multiple ways - just make sure not to mine the same tile twice! Mined coordinate pairs should therefore be removed from the list of available tiles.

2nd Function Specification: draw_field

Docstring:

"""
A handler function that draws a field represented by a two-dimensional list
into a game window. This function is called whenever the game engine requests
a screen update.
"""

Open sweeperlib.py and read the docstring of set_draw_handler to learn how to implement a draw

handler

. The field must be retrieved from the state dictionary using the "field" key. When drawing tiles, you need to multiple their list indices by the size of the tile sprite (which you can see by looking at the tile image file properties). The part where you iterate through the field will be very similar to a previous exercise.

3rd Function Specification: main

def main():
    """
    Loads the game graphics, creates a game window and sets a draw handler for it.
    """
    
    sweeperlib.load_sprites(#you need the path to the sprites folder here)
    sweeperlib.create_window(600, 400)
    sweeperlib.set_draw_handler(draw_field)
    sweeperlib.start()

Function Testing:'

The main program must be placed inside the if __name__ == "__main__":

conditional statement

. The main program's purpose is to test your functions. This is done by creating a 15x10 field where we place 35 mines. The mines are placed by

calling

the place_mines function once. The field can be created with this snippet:

field = []
for row in range(10):
    field.append([])
    for col in range(15):
        field[-1].append(" ")

state["field"] = field

In addition you need the aforementioned list of available coordinates. This can be created with the following snippet. Pay attention to the connection between dimensions, rows, columns, and coordinates.

available = []
for x in range(15):
    for y in range(10):
        available.append((x, y))

After this you should first call your place_mines function, followed by the main function.

Use Examples:

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Spectral Assignment: Pointing is Rude...¶

...but oh so practical - at least when it comes to pointing things on the screen with a mouse. This exercise teaches you a couple of skills that will be important in Spectral Matters: displaying a figure inside an application window, and reading mouse clicks from it.

Learning goals: Drawing a figure using matplotlib and guilib together. Implementing a mouse handler for the figure. Storing event information to program memory.

Goal: A program that draws a figure, and reports the x and y data values of the clicked point.

Introduction:

A figure embedded into an application window consists of three parts: the canvas, the figure, and a subplot. Our guilib's create_figure returns all of these - your task is to draw using them. The former is a matplotlib Figure object - it's documentation is here. Note that the figure itself cannot be drawn to - you need to use the subplot instead. The subplot is a matplotlib Axes object - documenation here here In some cases the figure is not displayed until the canvas object's draw method is called - you need to do this in your code even if you can see the figure without it.

The mouse

handler

follows the same principles as the button handler from the last exercise but it does have one parameter: a mouse event (documentation). This event is an

object

with a few important

attributes

. The key ones are:

x and y which are the screen coordinates that were clicked
button, the button that was clicked (1 = left, 2 = middle, 3 = right)
xdata and ydata that are the axis values in the clicked point

The exercise also needs a similar

dictionary

as the last one but due to its broader nature, we'll name it state because it contains general information about the program's state. A new key-value pair is added to the dictionary. You should save all clicked data values to this value as

tuples

state = {
    "textbox": None,
    "points": []
}

1st function specification: choose_point

Docstring
:

"""
Receives a mouse event from a mouse click and reads the x and y data 
values from it. The values are printed into a textbox, and saved to a list
in the program's state dictionary.
"""

Parameters
:

mouse event (matplotlib MouseEvent object)

The function needs to read the axis values from the mouse event it receives. These values are in the xdata and ydata attributes. The values are written into the textbox with two decimal precision - see the message format from the examples. This point should also be appended to the points list inside the state dictionary. This is important because in the course project you need to access previously selected points. When points are saved into the state dictionary like this, they are conveniently available.

2nd function specification: main

Docstring:

"""
Creates a user interface that contains an interactive figure and a textbox.
A plot based on data received as parameters is drawn into the figure.
"""

Parameters:

x axis data (list of floats)
y axis data (list of floats)

This function has the same purpose as the one in the previous exercise. This time the the interface is split vertically. The upper frame contains the figure. You can check the create_figure docstring for information on how to add one. The handler should be the choose_point function we just implemented. The bottom frame contains the familiar textbox. In addition the function should plot the data it receives.

An example of the result can be found at the end.

Function Testing:

if __name__ == "__main__":
    datax = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
    datay = [0.0, 0.19, 0.36, 0.51, 0.64, 0.75, 0.84, 0.91, 0.96, 0.99, 1.0, 0.99, 0.96, 0.91, 0.84, 0.75, 0.64, 0.51, 0.36, 0.19, 0.0]
    main(datax, datay)

Use Examples:

*The interface should look like this. Exact measurements can differ.*

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Circuit Assignment: Coder's Complex¶

We've already learned that Python will happily eat complex numbers. Last time we handled them in the terminal but how about prompting numbers in a graphical interface? This might be needed in Run, Circuit! Run! so it should be learned at some point. We can learn about error messages while we're at it.

Learning goals: Prompting and handling user inputs in a graphical user interface.

Goal: A program that calculates polar presentation for complex numbers.

Introduction:

You can use the interface from the previous exercise as a base. A new dynamic component is added to the program to keep company for the lonely textbox: a text field where the user can type a complex number. Like before, a referenced to this new component should be saved into a dictionary so that it can be accessed from a handler function. Start the program with the following dictionary:

elements = {
    "textbox": None,
    "textfield": None
}

1st Function Specification: convert_to_polar

Docstring
:

"""
Reads a complex number from an input field and converts it to polar 
representation, using degrees for the angular component. The complex number
and its polar representation are written into a textbox.
"""

This is

handler

and therefore doesn't have any parameters, nor does it return anything. The input is read from a text field that can be accessed through the elements dictionary (guilib has a function for reading text fields). If the user's input isn't a valid complex number, they are notified about the error with a popup window. There's a function for this as well in the library.

The conversion

function

itself should be already familiar. Once again the angle has to be converted from radians to degrees. The result is written into the textbox as seen in the examples. All floats are presented with three decimal precision.

Whether the conversion was successful or not, the handler should clear the input field once it's done.

2nd Function Specification: main

Docstring:

"""
Creates a user interface window with text field and two buttons on the left
side, and a textbox on the right side.
"""

The main function is based on the last exercise. The new additions are the aforementioned text field to the left frame, and an instruction label above it (that says e.g. "Complex number:"). Remember to assign the value returned by the creation function to the elements dictionary. The test button is replaced by a conversion button which uses the function we just implemented as its handler.

Function Testing:

if __name__ == "__main__":
    main()

Use Examples:

*Example behavior when the user gives a valid complex number.*

*Example behavior when the user inputs something else.*

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Duck Assignment: Flight path¶

In this assignment we are launching a box into air and drawing its flight path using sweeperlib library. Box is drawn in real-time as its coordinates are being updated.

Learning Goals: Calculating velocity vectors from polar coordinates, updating coordinates in real-time by object's velocity. Implementing simple gravity.

Goal: A program that shows a duck's flight path after a launch.

Introduction:

This task uses the same library module as the previous one. You'll also need the duck game graphics package, which you can extract into the same folder with your code. You'll find these in the resources section of this assignment. YOu'll also find a template where you should place the functions implemented in this exercise. The template comes with a keyboard interface for launching the duck, and a draw handler for drawing the interface.

1st Function Specification: initial_state

Docstring
:

"""
Puts the game back into its initial state: the duck is put back into the
launch position, its speed to zero, and its flight state to False.
"""

The function updates initial values into the game dictionary. The initial value for both coordinates is 40, the speeds are set to 0, and the "flight" key's value is set to False.

2nd Function Specification: launch

Docstring
:

"""
Launches a duck and calculates its starting velocity. Stores x and y velocity
components to the game dictionary.
"""

The function uses angle and force to calculate velocities along each axis. This calculation has been touched on previously in a certain early assignment. The function also sets "flight" to indicate that a launch has happened, allowing flight function to begin updating duck's values.

This function does not have return values or parameters. Instead it makes changes directly to the values of a global dictionary game.

3rd Function Specification: flight

Docstring:

"""
Updates duck's x and y coordinates based on corresponding velocity vectors.
"""

Parameters:

elapsed (
float
)

Interval function is called approximately every 1/60 second (slight inaccuracy is to be expected). The elapsed parameter holds the actual elapsed time since the function was last called. This parameter can be ignored during this exercise but the library's function call uses it.

After a launch the function updates new coordinates based on velocity. Due to the duck's superior aerodynamic properties, air friction can be completely ignored. Therefore the only external force affecting the duck's velocity is gravity, and it only affects the y component of velocity. Use 1.5 as the value for gravitational acceleration. This value is subtracted from the y velocity every time the function is called.

When the duck's y coordinate drops to zero or below, the flight has ended. The initial_state function should be called to communicate this change to the game logic. Note that this function should not do anything if the duck hasn't been launched. The "flight" key indicates this state.

Use Examples:

Assignment is slightly unusual since we cannot simply compare input values to expected outputs. Therefore we have also included a few numbers on the background of the UI. Box should pass through these numbers when using according angle and force values. Use these numbers for testing your program.

Number	Angle	Force
1	40	30
2	40	40
3	80	35
4	90	35
5	50	45

Resources:

sweeperlib.py

sprites.zip

flight_template.py

import math
import sweeperlib


WIN_WIDTH = 1200
WIN_HEIGHT = 600
GRAVITATIONAL_ACCEL = 1.5

game = {
    "x": 40,
    "y": 40,
    "angle": 0,
    "force": 0,
    "x_velocity": 0,
    "y_velocity": 0,
    "flight": False
}

def initial_state():

    *** Write your box initialization function here. ***

def launch():

    *** Write your box launching function here. ***


def flight(elapsed):

    *** Write your flight path updating function here. ***


def draw():
    """
    This function handles interface's and objects drawing.
    You do NOT need to modify this.
    """
    sweeperlib.clear_window()
    sweeperlib.draw_background()
    sweeperlib.begin_sprite_draw()
    sweeperlib.prepare_sprite("x", game["x"], game["y"])
    sweeperlib.draw_sprites()
    sweeperlib.draw_text("{}°\tforce: {}".format(game["angle"], game["force"]), 10, 505)
    sweeperlib.draw_text(
        "Q: Quit  | "
        "R: Reset |  "
        "←/→: Set angle |  "
        "↑/↓: Set Force  |  "
        "Space: Launch",
        10, 560,
        size=20
    )
    sweeperlib.draw_text("1", 380, 175, size=22)
    sweeperlib.draw_text("2", 830, 225, size=22)
    sweeperlib.draw_text("3", 170, 455, size=22)
    sweeperlib.draw_text("4", 50, 455, size=22)
    sweeperlib.draw_text("5", 700, 455, size=22)


def keypress(sym, mods):
    """
    This function handles keyboard input.
    You do NOT need to modify this.
    """
    key = sweeperlib.pyglet.window.key

    if sym == key.Q:
        sweeperlib.close()

    if sym == key.R:
        initial_state()

    if sym == key.RIGHT:
        game["angle"] -= 10
        if game["angle"] < 0:
            game["angle"] = 350
    elif sym == key.LEFT:
        game["angle"] += 10
        if game["angle"] > 350:
            game["angle"] = 0

    if sym == key.UP:
        if game["force"] < 50:
            game["force"] += 5
    elif sym == key.DOWN:
        if game["force"] >= 5:
            game["force"] -= 5
        else:
            game["force"] = 0

    if sym == key.SPACE:
        launch()


if __name__ == "__main__":

    sweeperlib.load_sprites("sprites")
    sweeperlib.create_window(width=WIN_WIDTH, height=WIN_HEIGHT)
    sweeperlib.set_draw_handler(draw)
    sweeperlib.set_keyboard_handler(keypress)
    sweeperlib.set_interval_handler(flight)
    sweeperlib.start()

Course Project Exercises 3¶

And finally choose on of these. These tasks are not required for minimal course completion.

Mine Assignment: Flood Survey¶

Floodfill is a basic algorithm that has all kinds of uses in programming. For instance it can be used to determine the size of any limited area with arbitrary shape. The fill tool of drawing programs is also based on it. Floodfill can also be used to navigate labyrinths or calculate how far a game character can move in varied terrain. Coincidentally it also plays a critical role in Minestomping where there's a need to open empty tiles in a way that expands to every direction without revealing the mines. It's not the easiest algorithm to figure out without any programming experience so we've included a step-by-step guide into this assignment.

In this exercise a probe droid is exploring the surface of a planet ja marking unknown territory as safe while avoiding areas that were previously marked as dangerous.

Learning goals: Understand how the floodfill algorithm works and learn about implementing somewhat complex algorithms in Python. Removing items from lists without turning the program into a slog.

Goal: A program that explores connected unknown tiles on a map.

Introduction:

You can draw the field similarly as in the last exercise. Grab the draw_field function from there. The main function is also mostly the same (see below).

1st function specification: floodfill

Docstring
:

"""
Marks previously unknown connected areas as safe, starting from the given
x, y coordinates.
"""

Parameters
:

the planet to explore (2-dimesional
list
)
starting point x coordinate (integer)
starting point y coordinate (integer)

The map of the planet contains two kinds of characters: unknown " " and dangerous "x". A safe tile is marked with "0". Your task is to start from the initial point and proceed to mark all connected tiles as safe. If the initial point is dangerous, nothing is done. You need to follow the provided step-by-step instructions for the algorithm quite accurately. In particular you need to avoid using

recursion

(you know you're using it if your floodfill function calls itself at any point).

The floodfill is started by creating a list with one item: a tuple that contains the starting point's coordinates. After initializing the list, the program moves on to a

loop

that runs until the entire connected area is filled. Each

iteration

of the loop proceeds as follows:

a new item is taken for processing from the aforementioned list (note: it has to be removed) - there's a method for this
it is marked as safe by replacing the character in those coordinates of the planet list with "0"
iterate through all surrounding coordinates (8 total, but be mindful of borders!) (see the ninja exercise for how to do this)
each tile that is unknown is added to the aforementioned list

This way the list that contains coordinate pairs keeps growing at the same time as it is consume, and only becomes entirely empty once all connected unknown tiles have been explored. Marking a tile as safe is done at the beginning of each iteration. We know the tile is safe because it was added to the list on a previous iteration, and the algorithm only adds unknown tiles to the list.

The function doesn't return anything.

2nd function specification: main

Docstring:

"""
Loads the game graphics, creates a game window, and sets a draw handler
"""

Parameters:

planet (a list that represents the planet, see below)

This function is based on the previous main function. We do note however that the planet shown below does not fit nicely into a 600x400 window. Change the window size accordingly - the best way to do this is to use the len function to get the field's dimensions and multiply them with the sprite dimensions.

Function Testing:

You need a main program that calls your functions for testing. You can use the following planet in your main program:

planet = [
    [" ", " ", " ", "x", " ", " ", " ", " ", " ", " ", " ", "x", " "], 
    [" ", " ", "x", "x", " ", " ", " ", "x", " ", " ", " ", "x", " "], 
    [" ", "x", "x", " ", " ", " ", " ", "x", " ", " ", "x", "x", " "], 
    ["x", "x", "x", "x", "x", " ", " ", "x", " ", "x", " ", " ", " "], 
    ["x", "x", "x", "x", " ", " ", " ", " ", "x", " ", "x", " ", " "], 
    [" ", " ", "x", " ", " ", " ", " ", " ", " ", "x", " ", " ", " "]
]

Call the floodfill function with a suitable starting point. Finally call the main function so you can see what the floodfill did.

Speed Requirements:

Unlike every exercise in this course, this one will check how fast your code executes. Slow execution will lead to lower points or completely failing. The primary cause for slowness is bad removal of items from the list. If items are removed from the beginning or middle of the list, a chain reaction is caused where all the remaining list indices must be updated (imagine the items being placed one slot closer to the beginning, one at a time). You won't notice the difference with a small field, but will notice with the 100x100 field included in the tests. Removals must be done from the end of the list.

Furthermore, remove is not a good method in this task beause it removes the first matching item from the list. This becomes a problem because the algorithm can place the same coordinate pair multiple times into the list. So even if you try to remove the last item, it is likely that one of its copies earlier in the list gets removed instead. Investigate list methods and find a more suitable method for this task.

Another way to make the checking time out is to make an

infinite loop

. For instance if your algorithm doesn't make sure it doesn't enter tiles it has already visited, it will end up visiting the same tiles over and over infinitely.

Executing the tests under 10 seconds is a requirement for full points. Furthermore, if the execution goes longer than 20 seconds, the checking will be interrupted, and you will get no other feedback except a notification that it took too long. This is to prevent the checking backend from getting blocked by too many slow processes running.

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Spectral Assignment: Dataminer in the Junkyard¶

This exercise teaches you a basic skill that is required for all kinds of data processing: reading data files. You've received a request from a researcher who konws nothing about programming. In addition they are very, very messy with their files - the data folders can include all kinds of trash like vintage meme pictures. Some data files are broken too. In general it's preferable for data readers to be able to find the real data from somewhat less organized folders. Program requirements are hard to keep in mind when saving things to the hard drive without much thought.

Learning goals: Reading data from multiple

files

data structures

in a program. Figuring out broken files and the correct way to handle them. Reading data rows.

Goal: A program that reads data from multiple files to program memory.

Introduction:

To make this task seem a bit more relevant we've given you a script that creates a bunch of random data files (check "resources"). All files generated by the script are intact, so you have to break some of them manually. While you're at it, copy your holiday pictures into the same folder to confuse your program a bit more. Run the script in the terminal with a

command line argument

that indicates which folder you want the data to go to.

You can also copy the main function from the Just an Ordinary Window exercise.

1st function specification: read_data

Docstring
:

"""
Reads all data files from the given folder. Skips files that don't have the
.mydat extension and files that have errors in them. The names of faulty .mydat
files are reported to the user.
"""

Parameters
:

target folder's path (
string
)

Returns
:

contents of the data files as a
data structure
(list of 3 item tuples)
names of faulty .mydat files (list of strings)

The function has to go through the contents of the folder and find all all .mydat files, and read their contents (other files are skipped silently). Data is appended to the program's data structure only when the end of each file is reached. If an error is encountered while reading a file, all data from that file is discarded, and the file's name is added to the list of faulty files. Correct data rows will look like:

Tomomi, 154.3578,12.9402

In other words each data row has three comma-separated values. The first one is always string. Each data row is parsed into a

tuple

that contains a string, and two

floats

, e.g.:

("Tomomi", 154.3578,12.9402)

These tuples should be appended to a temporary list first, and only added to the actual data list when the entire file has been read. This data list is returned when all files have been processed. You should also keep in mind that files may or may not have an empty line at the end. Depending on your implementation this can require additional processing.

2nd function specification: open_folder

Docstring:

"""
A button handler that opens a dialog the user can use to choose a data folder.
Loads data from the selected folder and reports the number of rows read and the
names of any faulty files into a textbox.
"""

This function should open a folder dialog (with a guilib function), and use its return value to call the read_data function. When the data has been read, the names of all faulty files are written (e.g. as "Faulty file: x") to the textbox, and finally the number of data rows read.

Function modification: main

Change the test button's label to "load" or something else descriptive, and the handler to the open_folder functin.

Function Testing:

if __name__ == "__main__":
    main()

Use Examples:

Resources:

generate_data.py

import os
import sys
import random

NAMES = ["Squall", "Cloud", "Celes", "Yuna", "Pikachu", "Bulbasaur", "Winnie the Pooh", "Eeyore", "Eunji", "Tomomi", "Haruna", "Seungyeon", "Ihsahn", "Abbath", "Fenriz"]

CHARS = "abcdefghjiklmnopqrstuvwxyz"

def gen_data(folder):
    os.makedirs(folder, exist_ok=True)
    for i in range(10):
        with open(os.path.join(folder, "".join([random.choice(CHARS) for x in range(random.randint(4, 10))]) + ".mydat"), "w") as target:
            for i in range(random.randint(4, 20)):
                target.write("{},{:.4f},{:.4f}\n".format(
                    random.choice(NAMES),
                    random.random() * 1000,
                    random.random() * 100
                ))                
    
if __name__ == "__main__":
    try:
        gen_data(sys.argv[1])
    except IndexError:
        print("Usage:")
        print("python generate_data.py folder")

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Circuit Assignment: A Circuitful of Resistors¶

This exercise is about drawing simple circuit diagrams inside the application window. You're probably shocked to know that this knowledge is needed in the Run, Circuit! Run! course project. In this program the user enters a bunch of resistors to the circuit, and the circuit diagram is updated whenever something is added to it. Once again we have a helper library that simplifies this process to a level that suits this course.

Learning goals: Using the circuitry module to draw circuit diagrams. Prompting and saving components in a graphical user interface.

Goal: A program that prompts for serial-connected resistors and draws them along with a voltage source.

Required installation: SchemDraw

The actual worker behind the scenes for drawing circuits is the SchemDraw module. Installation process is the same as for matplotlib (i.e. pip install schemdraw==0.8. You can look into the library in its documentation but this is not required because we're using a helper library. Note that we're installing the 0.8 version because the latest one doesn't work with the current SchemCanvas module.

Introduction:

You also need two more modules that were created for this course: the circuitry module which includes circuit drawing functions, and SchemCanvas which allows SchemDraw to draw inside the application window. You don't need to look at the SchemCanvas module, it goes quite a bit beyond this course.

circuitry.py

SchemCanvas.py

Once again it's a good idea to define a dictionary at the beginning of the code for storing references and values during execution.

state = {
    "textfield": None,
    "textbox": None,
    "circuit": None,
    "components": [],
    "voltage": 0,
    "frequency": 0,
}

1st Function Specification: set_voltage

Docstring
:

"""
Reads a float value from an input field and sets it as the circuit's voltage.
"""

This is a handler function that tries to read a number from the textfield and save it to the state dictionary. If the field doesn't contain a valid number, a message is displayed with a popup window similarly to the last exercise. It's also considered good manners to clear the field after reading its value. To keep the UI responsive, it should also report the new voltage in the textbox.

2nd Function Specification: set_frequency

Docstring:

"""
Reads a float value from an input field and sets it as the circuit's frequency.
"""

Same as above but for frequency.

3rd Function Specification: add_resistor

Docstring:

"""
Reads a float from an input field and adds a resistor with the read value as
its resistance. The resistor is added to the sole loop in the circuit.
Updates the circuit diagram.
"""

Same as the two above, but instead of saving the value directly, a new item is added to the components list: a two value tuple where the first item is "r" and the second is the float value. After adding the resistor, the circuit diagram needs to be updated using the draw_voltage_source, draw_loop, and draw_circuit functions.

SchemDraw is intended for drawing a complete circuit and doesn't directly support updating the diagram once it's ready. Therefore whenever something needs to be added to the circuit, the diagram needs to be cleared entirely and redrawn from the beginning. Since drawing the circuit always start form the voltage source, the reset happens when draw_voltage_source function is called. Loops are drawn one at a time. The circuitry module does most of work in component layout but you may need to do some fine adjustments (only in the course project though, this exercise is rather straightforward in terms of layout). Note that these functions only prepare the circuit diagram - it is drawn only when the draw_circuit function is called.

Study the functions mentioned here to understand how they work.

Invalid component value should give an error message in the form of a popup window.

4th Function Specification: main

Docstring:

"""
Creates a user interface window with input field, four buttons, and a textbox
on the left side. The right side contains a circuit diagram.
"""

The interface is created in the same way as previously. Buttons are connected to the functions made in this exercise. References to the textfield, textbox, and circuit diagram are stored to the state dictionary. You should set suitable dimensions for the textbox and circuit diagram yourself.

Function Testing:

if __name__ == "__main__":
    main()

Use Examples:

*The interface should look approximately like this.*

Give feedback on this content

Was this task useful for learning?

Comments about the task?

Duck Assignment: Boxfall¶

In this assignment it's raining boxes. When dropping boxes, it's important to make sure they don't end up inside one another. In our duck plans this mechanism is needed when a target gets blown out from underneath a box, and the box needs to fall accordingly.

Learning goals: Applying gravity to boxes. Collision detection among a group of objects.

Goal:' A program that drops a bunch of randomly placed boxes down from the sky so that they pile up on top of each other.

Introduction:

Just like in the previous assignments, once again all data should be placed inside a

dictionary

. Use the dictionary shown below. You should also pick up the habit of defining important costants like window size with, well,

constants

WINDOW_WIDTH = 1200
WINDOW_HEIGHT = 600
GRAVITY = 1.5

game = {
    "boxes": []
}

1st Function Specification: create_boxes

Docstring
:

"""
Creates a speficied number of boxes with random positions inside the specified
area. Boxes are represented as dictionaries with the following keys:
x: x coordinate of the bottom left corner
y: y coordinate of the bottom left corner
w: box width
h: box height
vy: falling velocity of the box
"""

Parameters:
:

number of boxes (integer)
minimum height for placement (integer)

Returns
:

a list that contains box dictionaries

The function randomizes a set of boxes. The boxes are square (i.e. width == height). Boxes must be placed inside the window, and above the desired minimum height. The boxes are allowed to overlap (the dropping algorithm takes care of this problem). The falling velocity of each box is set to 0. Both dimensions are set to 40. The boxes are placed inside a list that is returned.

2nd Function Specification: drop

Docstring:

"""
Drops rectangular objects that are given as a list. Each object is to be
defined as a dictionary with x and y coordinates, width, height, and falling
velocity. Drops boxes for one time unit.
"""

Parameters:

List of dictionaries, each representing a rectangle

The function goes through all boxes in the list and figures out whether each of them should fall or stay in place. In order to do this, boxes must be iterated through in ascending order of height (measured from the top of the box). Boxes that are lower will be dropped first. A box stays still if its bottom touches the ground (y <= 0) or the top of another box. In both cases the box's y coordinate is set to the level where it has stopped (i.e. zero, or top of the box below it).

*Example boxes. Red boxes are falling. Iteration order is shown with numbers. Box 8 is falling because box 7 below it is dropped first.*

A box that is falling has its falling velocity incremented by the gravital acceleration value, and then its y coordinate adjusted by the falling velocity. The boxes will fall at increasing velocity. Because of this it is also possible that a box will fall so fast that it passes through another box without ever touching it - this needs to be prevented in the implementation.

Note! Although the program itself only deals with 40x40 boxes, the function code itself is to be written in a way that it works for any rectangles of any size. Your code needs to read each box's width and height from the dictionary representation. The checker will also test the function with boxes of varying sizes.

Hint: When comparing boxes to other boxes, it is best to proceed downward from the current box. I.e. if we are currently on box 5 in the above picture, the comparisons would be made against boxes 4, 3, 2, and 1.

3rd Function Specification: draw

Docstring:

"""
Draws all boxes into the window.
"""

The draw handler needs to be implemented similarly to the previous ones. However, since there are multiple boxes now, a loop is needed for iterating through all of them. Make sure to call prepare_sprite once for each box. Like previously, use " " as the sprite key.

Testing:

You can use the main function from the previous assignment as the basis for testing. You just need to replace the draw handler with the one you just made, and the update handler with this one:

def update(elapsed_time):
    drop(game["boxes"])

After a while all boxes should have settled down in a way that they no longer overlap each other, and are "safely" standing on something. If you want to see what happens to the boxes, you can slow down the falling by setting the update handler's interval higher with its optional argument. This can be useful in finding bugs.

Give feedback on this content

Comments about these exercises