ALGORITHMS

Class Game
Instance Attributes
window # the window on which to draw
pause_time # pause time between drawing frames
close_clicked # indicates if close button was clicked
continue_game # indicates if game should continue
# add attributes as required
grid

Instance Methods/Blocks
initialize instance
initialize/create all instance attributes
create a 4x4 grid of tiles

Import image
Create a list to import images
Add the list twice
Randomize the list

play game
while not close_clicked
# ‘play’ a single frame
handle next event
draw the current frame
if continue_game:
update all game objects
decide if game should continue
pause before next iteration/frame

handle event
get next event from the event queue
If event type == QUIT
close_clicked = True
# check more events as required
If event type == MOUSEUP
Place the current player’s letter in the tile they clicked

update game objects

# update Game objects to new position in next frame

draw frame
erase the window
# draw the Game objects
draw each tile in the grid at its location
update the window
 decide if game should continue
# check if game should continue or not

Class Tile
Instance Attributes
rect # a rectangle that specifies the tile boundaries
surface # the game surface the tile is drawn to
content # the thing drawn inside of the tile
content_size # size (pixels) of tile content
fg_color # the color of things in the foreground of tile
bg_color # the color of things in the background of tile
border_width # how wide (pixels) the tile border is

Instance Methods/Blocks
initialize instance
set attributes based on arguments
create tile rectangle from x,y,width,height

draw
# stuff goes here
draw rectangle with appropriate borders
if tile contains contents, draw contents
 Code:

# Memory1
#
# 4x4 grid of rectangles are displayed.
# All 8 pairs are exposed

import time, pygame, random

from uagame import Window
from pygame.locals import *

# User-defined functions

def main():
# Creates the game window and game, and runs game
window = Window('Memory', 500, 400)
window.set_auto_update(False)
game = Game(window)
game.play()
window.close()

# User-defined classes

class Game:
# Defines a game of Tic Tac Toe

def __init__(self, window):

# Initialize a Game.
# - self is the Game to initialize
# - window is the uagame window object

# create all of the game attributes

self.window = window
self.pause_time = 0.04 # smaller is faster game
self.close_clicked = False
self.continue_game = True
self.index = 0
self.image_list = []
self.import_image()
self.grid = [ ]
self.create_grid()

def import_image(self):
prefix = "image"
suffix = ".bmp"
for i in range(1,9):
self.image_list.append(pygame.image.load("image" + str(i) + ".bmp"))

self.image_list = self.image_list + self.image_list

random.shuffle(self.image_list)
 def create_grid(self):
# creates our 4x4 grid of tiles by creating three
# separate rows, each one containing 3 tiles
# - self: the TTT game to create a grid for

for i in range(4):
self.create_row()

def create_row(self):
# creates a single row in our grid of tiles. Each
# row contains 3 tiles.
# - self: the TTT game to create a tile row for
one_row = [ ]

# calculate the dimensions that tiles need to be

tile_width = 400 / 4
tile_height = 400 / 4

# calculate the y-coordinates of tiles in this row.

# To do so, we need to know what row number we are
# creating tiles for. We can do that by taking the
# current len of the grid, e.g., len 0 = first row
row_index = len(self.grid)
tile_y = tile_height * row_index

# create each tile in the row. Tile x-coordinates are offset

# by tile’s index (times tile width) in the row.
for i in range(4):
tile_x = tile_width * i
index = 4*row_index + i
one_row.append(Tile(100, 4, 'Black',self.window, tile_x, tile_y, tile_width,
tile_height,self.image_list[index]))

# add the newly created row to our grid of tiles

self.grid.append(one_row)

def play(self):
# Play the game until the player presses the close box.
# - self is the Game that should be continued or not.

while not self.close_clicked: # until player clicks close box

# play frame
self.handle_event()
self.draw()
if self.continue_game:
self.update()
self.decide_continue()
time.sleep(self.pause_time) # set game velocity by pausing
 def handle_event(self):
# Handle each user event by changing the game state
# appropriately.
# - self is the Game whose events will be handled.

event = pygame.event.poll()
# close the game if someone has clicked on the close button
if event.type == QUIT:
self.close_clicked = True

# obtain position of mouse: event.pos

# go over each tile and see if it overlaps with the position
# if tile overlaps with event.pos, update tile content
if event.type == MOUSEBUTTONUP and self.continue_game == True:
for row in self.grid:
for tile in row:
tile.select(event.pos)

def draw(self):
# Draw all game objects.
# - self is the Game to draw
self.window.clear()

# draw each of our tiles

for row in self.grid:
for tile in row:
tile.draw()

self.window.update()

def update(self):
# Update the game objects.
# - self is the Game to update
pass

def decide_continue(self):
# Check and remember if the game should continue
# - self is the Game to check
pass

class Tile:
# represents a single on a Tic Tac Toe board

def __init__(self, content_size, border_width, fg_color, window, x, y, width, height,

image):

self.image = image

# attributes related to drawing our rectangle

self.rect = pygame.Rect(x, y, width, height)
self.border_width = border_width
 # attributes related to drawing our tile content
self.content_size = content_size
self.content = ''

# palette choices
self.fg_color = fg_color

# the window to draw our tile to

self.window = window

def draw(self):
# draws our tile contents and borders to the screen
# - self: the tile to draw

# draw our rectangle with borders

surface = self.window.get_surface()
rect_color = pygame.Color(self.fg_color)
surface.blit(self.image,(self.rect.x,self.rect.y))
pygame.draw.rect(self.window.get_surface(), rect_color, self.rect,
self.border_width)

main()