Learning Programming with Fundamentals of Computing

Introduction to Interactive Programming in Python - Week 6

This week's lecture covers reading mouse input as well as list methods and dictionaries. Last week's blog post discussed the list data type and several common list methods. This blog post will explain the dictionary data type as well as various dictionary methods.

This week's mini project is writing the merge function for the game 2048. In next week's mini project we will build the rest of the game.

• Dictionary: A dictionary is an unordered collection of key: value pairs, with each key in a dictionary being distinct. Unlike sequences (i.e., lists), which are indexed by a range of numbers, dictionaries are indexed by keys, which can generally be any immutable type (e.g., strings, numbers, certain tuples). Thus, it's useful to use a dictionary over another data structure, such as a list, when you need to associate values with keys so you can efficiently look them up later. A pair of braces creates an empty dictionary: {}. Below are some common dictionary methods:
  • Get Value in Dictionary by Key: a_dict[key] or a_dict.get(key). Note that if the key is not in the dictionary, a_dict[key] raises a KeyError error, whereas a_dict.get(key) returns None.
  • Set Value for Key in Dictionary: a_dict[key] = value. This mutates the dictionary a_dict so that the given key now maps to the given value.
  • Check if Keys is in Dictionary: a_dict.has_key() or key in a_dict. The former returns a Boolean expression based on whether the given key is a key in the dictionary a_dict.
  • Get List of all Key/Value Pairs: a_dict.items(). This returns a list of (key, value) pairs for all the keys in dictionary a_dict. This is useful for looping over all the key/value pairs in a dictionary.
  • Get List of all Keys: a_dict.keys(). This returns a list of the keys in dictionary a_dict.
  • Get List of all Values: a_dict.values(). This returns a list of the values in dictionary a_dict.

Mini Project 6

• Creating and Starting Frame: The first thing we need to do is create a canvas to draw the objects in our Pong game, such as the ball and paddles, and create a GUI with buttons to start and reset the game. In CodeSkulptor, the built-in GUI library is called simplegui. In Python there are several different libraries you can use for creating GUI applications, such as Tkinter. The syntax will likely vary a little bit from library to library, but the overall concepts are the same. Notice that the create_frame function takes as parameters the global variables WIDTH and HEIGHT. All of the global variables are capitalized to signify that we don't want our functions to modify their values.
• spawn_ball and new_game: The new_game() function initializes a bunch of global variables. Note that these global variables are in lower case, to differentiate them from the global variables whose values shouldn't be modified by any function. These global variables include the scores as well as the positions and velocities of the ball and paddles, which will be modified by the event handlers as players play the game. The spawn_ball(direction) function randomly sets the velocity of the ball in either the left or right direction. Note that ball_vel[1] is a negative value regardless of whether the direction is "left" or "right". This will cause the ball to move towards the top of the canvas in either direction every time a new game starts or a player scores a point.
• Event Handlers: There are three types of events in this implementation of Pong: keyboard events, button events, and drawing events. Keyboard events and button events are more straightforward than drawing events, so we'll deal with those first.
  • Keyboard events: In Pong, we use the "w" and "up" and "s" and "down" keys to move the left and right paddles up and down, respectively. To move the paddles, we increase their velocities when the keys are pressed, and set their velocities to zero when the keys are unpressed.
  • Button events: In my implementation of Pong in Python, I included two buttons: one to start the game and another to reset the game. The start event handler randomly chooses "left" or "right" as the direction parameter to pass to the spawn_ball function. The reset event handler simply calls the new_game function and sets the value of the global variables score1 and score2 to zero.
  • Drawing events: There are a few objects we'll need to draw to the canvas to create our Pong program, including static items like lines and text, a ball object whose velocity will change throughout the game, and paddles that will move up and down at a constant velocity when certain keys are pressed.
    • Static items: To draw the mid line and gutters, as well as the scores, on the canvas we simply need to use the draw_line and draw_text methods, respectively.
    • Ball: To draw the ball on the canvas, we use the draw_circle method. We also need to update the position of the ball every time the draw handler is called - this will have the effect of making the ball look like it's in continuous motion. However, in reality the computer is simply refreshing its buffer 60+ times per second, and each time it draws the ball in a different position on the canvas. In the code snippet below, notice that we're making sure that the ball stays on the screen by detecting any collisions with the top and bottom of the canvas, and reflecting the ball upon collisions by negating its velocity vector. This is what causes the ball to bounce off the top and bottom edges of the screen rather than drift away.
    • Paddles: We draw the paddles the same way we draw the mid line and gutters - by using the draw_line function. Similarly, we keep the paddles on the screen just like we kept the ball from drifting beyond the top and bottom of the canvas. The most interesting part of this entire program is writing the logic for detecting collisions between the ball and the paddle. This code says when there's a collision between the ball and the left or right edge, check whether that collision is between the top and bottom of the paddle on that side of the canvas. If it is, then we'll change the direction of the ball and increase the ball's velocity (in this case, by 25%). Otherwise, we adjust the scores and the ball respawns in the center of the canvas and shoots off in the direction of the scoring player.

See my complete implementation of Mini Project 5 on GitHub.