Coding

After taking online classes through Coursera from Rice University, University of London, and University of Illinois, I was able to create some games from Python and Java.

I programmed games such as

A coloring book
Asteroids
Pong
Memory matching game

These are designed to be reminiscent of early video games and childhood favorites.

Coloring Book (Built with Processing)

  
    

/* @pjs preload="bulbasaur.png, charmander.png, index.png, off-bulba-button.png, off-charmander-button.png, off-pikachu-button.png, off-squirtle-button.png, on-bulba-button.png, on-charmander-button.png, on-pikachu-button.png, on-squirtle-button.png, panels.png, pikachu.png, squirtle.png"; */

PImage [] Pikachubutton = new PImage[2]; // array needed for button
PImage [] Charmanderbutton = new PImage[2];
PImage [] Squirtlebutton = new PImage[2];
PImage [] Bulbasaurbutton = new PImage[2];
int PikachuPlayMarker = 0; //marker for Pikachu image button
int CharmanderPlayMarker = 0;
int SquirtlePlayMarker = 0;
int BulbasaurPlayMarker = 0;
int brushsize =10; //initial size of brush
int blue = 255;
int green = 255;
int red = 255;
Maxim maxim;
AudioPlayer player;

void setup()
{
  size(480, 800);
  imageMode(CORNER);
  PImage index = loadImage("index.png");
  background(index);
  Pikachubutton [0] = loadImage("off-pikachu-button.png");
  Pikachubutton [1] = loadImage("on-pikachu-button.png");
  Charmanderbutton [0] = loadImage("off-charmander-button.png");
  Charmanderbutton [1] = loadImage("on-charmander-button.png");
  Squirtlebutton [0] = loadImage("off-squirtle-button.png");
  Squirtlebutton [1] = loadImage("on-squirtle-button.png");
  Bulbasaurbutton [0] = loadImage("off-bulba-button.png");
  Bulbasaurbutton [1] = loadImage("on-bulba-button.png");
  background(index);
  maxim = new Maxim(this);
  player = maxim.loadFile("pikachu.wav");
  player1 = maxim.loadFile("charmander.wav");
  player2 = maxim.loadFile("squirtle.wav");
  player3 = maxim.loadFile("bulbasaur.wav");
  player.setLooping(false);

}

void draw()
{
  //the brush
  stroke(red,green,blue);   
  strokeWeight(brushsize);
    if (mousePressed == true) {
      line(mouseX, mouseY, pmouseX, pmouseY);
    }  
  //thou shall stay in the lines!
  PImage panels = loadImage("panels.png");
  image(panels, 0, 0);
 
  //draw the buttons
  image(Pikachubutton[PikachuPlayMarker], 46, 571);
  image(Charmanderbutton[CharmanderPlayMarker], 144, 571);
  image(Squirtlebutton[SquirtlePlayMarker], 240, 571);
  image(Bulbasaurbutton[BulbasaurPlayMarker], 338, 571);
}


void mousePressed()
{
  // so brush doesn't go too big or too small
  if (brushsize<2)
   {brushsize = 2;}
  if (brushsize>60)
   {brushsize = 60;}  

// pressing the + and -  buttons allow the user to change the brush size   
  if(mouseX>371 && mouseX<396 && mouseY>729 && mouseY<755)
    {
       {brushsize++;}
     }  
  if(mouseX>403 && mouseX<428 && mouseY>729 && mouseY<755)
    {
       {brushsize--;}
     }
 
  
  //pressing Pikachu button gets a Pikachu!
  if (mouseX>46 && mouseX<137 && mouseY>571 && mouseY<599){
    PImage Pikachu = loadImage("pikachu.png");
    background(Pikachu);
    BulbasaurPlayMarker = 0;
    SquirtlePlayMarker = 0;
    CharmanderPlayMarker = 0;
    PikachuPlayMarker = 1;
    player.stop();
    player.play();
  }

  //pressing Charmander button gets a Charmander!
  if (mouseX>144 && mouseX<235 && mouseY>571 && mouseY<599){
    PImage Charmander = loadImage("charmander.png");
    background(Charmander);
    BulbasaurPlayMarker = 0;
    SquirtlePlayMarker = 0;
    CharmanderPlayMarker = 1;
    PikachuPlayMarker = 0;
    player1.stop();
    player1.play();
  }

  //pressing Squirtle button gets a Squirtle!
  if (mouseX>240 && mouseX<331 && mouseY>571 && mouseY<599){
    PImage Squirtle = loadImage("squirtle.png");
    background(Squirtle);
    BulbasaurPlayMarker = 0;
    SquirtlePlayMarker = 1;
    CharmanderPlayMarker = 0;
    PikachuPlayMarker = 0;
    player2.stop();
    player2.play();
  }

  //pressing Bulbasaur button gets a Bulbasaur!
  if (mouseX>338 && mouseX<429 && mouseY>571 && mouseY<599){
    PImage Bulbasaur = loadImage("bulbasaur.png");
    background(Bulbasaur);
    BulbasaurPlayMarker = 1;
    SquirtlePlayMarker = 0;
    CharmanderPlayMarker = 0;
    PikachuPlayMarker = 0;
    player3.stop();
    player3.play();
  }

//pressing the first row of colors
 //red
 if(mouseX>50 && mouseX<75 && mouseY>628 && mouseY<654)
  {red = 242;green = 108;blue = 79;}
 //orange
 if(mouseX>82 && mouseX<105 && mouseY>628 && mouseY<654)
  {red = 246;green = 142;blue = 86;}    
 //yellow
 if(mouseX>115 && mouseX<140 && mouseY>628 && mouseY<654)
  {red = 255;green = 245;blue = 104;}   
 //light green 
 if(mouseX>146 && mouseX<171 && mouseY>628 && mouseY<654)
  {red = 172;green = 211;blue = 115;}
 // dark green
 if(mouseX>178 && mouseX<203 && mouseY>628 && mouseY<654)
  {red = 124;green = 197;blue = 118;}
 // green blue
 if(mouseX>210 && mouseX<236 && mouseY>628 && mouseY<654)
  {red = 28;green = 187;blue = 180;}  
 // light blue
 if(mouseX>243 && mouseX<268 && mouseY>628 && mouseY<654)
  {red = 0;green = 191;blue = 243;}  
 // blue
 if(mouseX>275 && mouseX<300 && mouseY>628 && mouseY<654)
  {red = 86;green = 116;blue = 185;}  
 // dark blue
 if(mouseX>307 && mouseX<332 && mouseY>628 && mouseY<654)
  {red = 96;green = 92;blue = 168;}  
 // purple
 if(mouseX>338 && mouseX<364 && mouseY>628 && mouseY<654)
  {red = 133;green = 96;blue = 168;}  
 // pink
 if(mouseX>371 && mouseX<396 && mouseY>628 && mouseY<654)
  {red = 240;green = 110;blue = 170;}  
 // dark pink
 if(mouseX>403 && mouseX<428 && mouseY>628 && mouseY<654)
  {red = 242;green = 109;blue = 125;}  


//pressing the second row of colors
 //red
 if(mouseX>50 && mouseX<75 && mouseY>662 && mouseY<687)
  {red = 237;green = 31;blue = 36;}
 //orange
 if(mouseX>82 && mouseX<105 && mouseY>662 && mouseY<687)
  {red = 242;green = 101;blue = 34;}    
 //yellow
 if(mouseX>115 && mouseX<140 && mouseY>662 && mouseY<687)
  {red = 255;green = 242;blue = 0;}   
 //light green 
 if(mouseX>146 && mouseX<171 && mouseY>662 && mouseY<687)
  {red = 141;green = 198;blue = 63;}
 // dark green
 if(mouseX>178 && mouseX<203 && mouseY>662 && mouseY<687)
  {red = 57;green = 181;blue = 74;}
 // green blue
 if(mouseX>210 && mouseX<236 && mouseY>662 && mouseY<687)
  {red = 0;green = 169;blue = 157;}  
 // light blue
 if(mouseX>243 && mouseX<268 && mouseY>662 && mouseY<687)
  {red = 0;green = 174;blue = 239;}  
 // blue
 if(mouseX>275 && mouseX<300 && mouseY>662 && mouseY<687)
  {red = 0;green = 84;blue = 166;}  
 // dark blue
 if(mouseX>307 && mouseX<332 && mouseY>662 && mouseY<687)
  {red = 46;green = 49;blue = 146;}  
 // purple
 if(mouseX>338 && mouseX<364 && mouseY>662 && mouseY<687)
  {red = 102;green = 45;blue = 145;}  
 // pink
 if(mouseX>371 && mouseX<396 && mouseY>662 && mouseY<687)
  {red = 236;green = 0;blue = 140;}  
 // dark pink
 if(mouseX>403 && mouseX<428 && mouseY>662 && mouseY<687)
  {red = 237;green = 20;blue = 91;}    

//pressing the third row of colors
 //red
 if(mouseX>50 && mouseX<75 && mouseY>696 && mouseY<721)
  {red = 158;green = 11;blue = 15;}
 //orange
 if(mouseX>82 && mouseX<105 && mouseY>696 && mouseY<721)
  {red = 160;green = 65;blue = 13;}    
 //yellow
 if(mouseX>115 && mouseX<140 && mouseY>696 && mouseY<721)
  {red = 171;green = 160;blue = 0;}   
 //light green 
 if(mouseX>146 && mouseX<171 && mouseY>696 && mouseY<721)
  {red = 89;green = 133;blue = 39;}
 // dark green
 if(mouseX>178 && mouseX<203 && mouseY>696 && mouseY<721)
  {red = 25;green = 123;blue = 48;}
 // green blue
 if(mouseX>210 && mouseX<236 && mouseY>696 && mouseY<721)
  {red = 0;green = 116;blue = 107;}  
 // light blue
 if(mouseX>243 && mouseX<268 && mouseY>696 && mouseY<721)
  {red = 0;green = 118;blue = 163;}  
 // blue
 if(mouseX>275 && mouseX<300 && mouseY>696 && mouseY<721)
  {red = 0;green = 52;blue = 113;}  
 // dark blue
 if(mouseX>307 && mouseX<332 && mouseY>696 && mouseY<721)
  {red = 27;green = 20;blue = 100;}  
 // purple
 if(mouseX>338 && mouseX<364 && mouseY>696 && mouseY<721)
  {red = 68;green = 14;blue = 98;}  
 // pink
 if(mouseX>371 && mouseX<396 && mouseY>696 && mouseY<721)
  {red = 158;green = 0;blue = 93;}  
 // dark pink
 if(mouseX>403 && mouseX<428 && mouseY>696 && mouseY<721)
  {red = 158;green = 0;blue = 57;}

//pressing the fourth row of colors
 //light light brown
 if(mouseX>50 && mouseX<75 && mouseY>729 && mouseY<755)
  {red = 199;green = 178;blue = 153;}
 //light brown
 if(mouseX>82 && mouseX<105 && mouseY>729 && mouseY<755)
  {red = 198;green = 156;blue = 109;}    
 //brown
 if(mouseX>115 && mouseX<140 && mouseY>729 && mouseY<755)
  {red = 140;green = 98;blue = 57;}   
 //dark brown
 if(mouseX>146 && mouseX<171 && mouseY>729 && mouseY<755)
  {red = 96;green = 57;blue = 19;}
 // dark dark brown
 if(mouseX>178 && mouseX<203 && mouseY>729 && mouseY<755)
  {red = 54;green = 47;blue = 45;}
 // grey
 if(mouseX>210 && mouseX<236 && mouseY>729 && mouseY<755)
  {red = 85;green = 85;blue = 85;}  
 // black
 if(mouseX>243 && mouseX<268 && mouseY>729 && mouseY<755)
  {red = 0;green = 0;blue = 0;}  

 // eraser
 if(mouseX>338 && mouseX<364 && mouseY>729 && mouseY<755)
  {red = 255;green = 255;blue = 255;}  
 // plus brush sign
// if(mouseX>371 && mouseX<396 && mouseY>729 && mouseY<755)
//  {red = 158;green = 0;blue = 93;}  
 // minus brush sign 
// if(mouseX>403 && mouseX<428 && mouseY>729 && mouseY<755)
//  {red = 158;green = 0;blue = 57;}    
  

noStroke();
fill(red,green,blue);
ellipse(mouseX, mouseY, brushsize, brushsize);
  
}


  




  

Asteroids (Coded in Python)

  
    
 # program template for Spaceship
import simplegui
import math
import random

# globals for user interface
width = 800
height = 600
score = 0
lives = 3
time = 0
wrap = 10 #buffer space
rock_turn = (random.random() * (.2-.01) + .01) *random.choice([1, -1]) #a random number between .01 <= n < .2 or -.01 <= n < -.2   
rock_pos_x = random.randrange(wrap, width - wrap ) #random x location for rock. 
rock_pos_y = random.randrange(wrap, height - wrap ) #random y location for rock.
rock_vel_x = (random.random() * (5-.1) + .1) *random.choice([1, -1]) #random x velocity value .1 <= n < 5 or -.1 => n > -5.
rock_vel_y = (random.random() * (5-.1) + .1) *random.choice([1, -1]) #random y velocity value .1 <= n < 5 or -.1 => n > -5.    
lives = 3
started = False 
missile_group = set([]) 
rock_group = set([]) 
collisions = 0
num_collisions = 0
explosion_group = set([]) 

class ImageInfo:
    def __init__(self, center, size, radius = 0, lifespan = None, animated = False):
        self.center = center
        self.size = size
        self.radius = radius
        if lifespan:
            self.lifespan = lifespan
        else:
            self.lifespan = float('inf')
        self.animated = animated

    def get_center(self):
        return self.center

    def get_size(self):
        return self.size

    def get_radius(self):
        return self.radius

    def get_lifespan(self):
        return self.lifespan

    def get_animated(self):
        return self.animated

    
# art assets created by Kim Lathrop, may be freely re-used in non-commercial projects, please credit Kim
    
# debris images - debris1_brown.png, debris2_brown.png, debris3_brown.png, debris4_brown.png
#                 debris1_blue.png, debris2_blue.png, debris3_blue.png, debris4_blue.png, debris_blend.png
debris_info = ImageInfo([320, 240], [640, 480])
debris_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/debris2_blue.png")

# nebula images - nebula_brown.png, nebula_blue.png
nebula_info = ImageInfo([400, 300], [800, 600])
nebula_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/nebula_blue.png")

# splash image
splash_info = ImageInfo([200, 150], [400, 300])
splash_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/splash.png")

# ship image
ship_info = ImageInfo([45, 45], [90, 90], 35)
ship_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/double_ship.png")

# missile image - shot1.png, shot2.png, shot3.png
missile_info = ImageInfo([5,5], [10, 10], 3, 50)
missile_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/shot2.png")

# asteroid images - asteroid_blue.png, asteroid_brown.png, asteroid_blend.png
asteroid_info = ImageInfo([45, 45], [90, 90], 40)
asteroid_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/asteroid_blue.png")

# animated explosion - explosion_orange.png, explosion_blue.png, explosion_blue2.png, explosion_alpha.png
explosion_info = ImageInfo([64, 64], [128, 128], 17, 24, True)
explosion_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/explosion_alpha.png")

# sound assets purchased from sounddogs.com, please do not redistribute
soundtrack = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/soundtrack.mp3")
missile_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/missile.mp3")
missile_sound.set_volume(.5)
ship_thrust_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/thrust.mp3")
explosion_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/explosion.mp3")

# helper functions to handle transformations
def angle_to_vector(ang):
    return [math.cos(ang), math.sin(ang)]

def dist(p,q):
    return math.sqrt((p[0]-q[0])**2+(p[1]-q[1])**2)


# Ship class
class Ship:   
    def __init__(self, pos, vel, angle, image, info):
        self.pos = [pos[0],pos[1]]
        self.vel = [vel[0],vel[1]]
        self.thrust = False #whether ship is accelerating in forward direction (Boolean)
        self.angle = angle #ship's orientation
        self.angle_vel = 0
        self.image = image
        self.image_center = info.get_center()
        self.image_size = info.get_size()
        self.radius = info.get_radius()
        self.a_missile = Sprite(self.pos, self.vel, self.angle, 0, missile_image, missile_info, missile_sound)

        
    def draw(self,canvas):
        canvas.draw_image(self.image, self.image_center, self.image_size, self.pos, self.image_size, self.angle)

    def set_pos(self, p):
        self.pos = p
        
    def set_vel(self, v):
        self.vel = v                

    def set_angle_vel(self, ang_v):
        self.angle_vel = ang_v         
        
    def update(self):
        self.angle += self.angle_vel
        
        #position update
        self.pos[0] += self.vel[0] 
        self.pos[1] += self.vel[1] 

        
        if self.pos[0] > width + wrap: #stops space ship from going too far right 
            self.pos[0] = wrap

        if self.pos[0] < wrap: #stops space ship from going too far left 
            self.pos[0] = width + wrap

        if self.pos[1] > height + wrap: #stops space ship from going too far up 
            self.pos[1] = wrap

        if self.pos[1] < wrap: #stops space ship from going too far down 
            self.pos[1] = height + wrap

            
            
        #friction update
        
        friction_coefficient = 0.01
        acceleration = 0.15
        
        self.vel[0] *= (1 - friction_coefficient)
        self.vel[1] *= (1 - friction_coefficient)            
        
        
        #thrust update - acceleration in direction of forward vector
        forward = angle_to_vector(self.angle)
        
        if self.thrust:
            self.vel[0] += forward[0] * acceleration 
            self.vel[1] += forward[1] * acceleration
            
    def shoot(self):
        global missile_group
        
        ship_image_radius = 45 #ship radius = 35 + 10 for missile tip.  Thus 45.
        missle_min_vel = 8 #some constant

        #Missile spawn position        
        tip_position_x = self.pos[0] + ( ship_image_radius * math.cos(self.angle) )
        tip_position_y = self.pos[1] + ( ship_image_radius * math.sin(self.angle) )

        #Missile Velocity 
        missile_vel_x = self.vel[0] + ( missle_min_vel * math.cos(self.angle) )
        missile_vel_y = self.vel[1] + ( missle_min_vel * math.sin(self.angle) )
       
        a_missile = Sprite([tip_position_x, tip_position_y], [missile_vel_x, missile_vel_y], self.angle, self.angle_vel, missile_image, missile_info, missile_sound)
        
        missile_group.add(a_missile)        
        
    def get_position(self):
        return self.pos         

    def get_radius(self):
        return self.radius 
    
# Sprite class
class Sprite:
    def __init__(self, pos, vel, ang, ang_vel, image, info, sound = None):
        self.pos = [pos[0],pos[1]]
        self.vel = [vel[0],vel[1]] 
        self.angle = ang 
        self.angle_vel = ang_vel
        self.image = image
        self.image_center = info.get_center()
        self.image_size = info.get_size()
        self.radius = info.get_radius()
        self.lifespan = info.get_lifespan()
        self.animated = info.get_animated()
        self.age = 0
        if sound:
            sound.rewind()
            sound.play()
   
    def draw(self, canvas):
        canvas.draw_image(self.image, self.image_center, self.image_size, self.pos, self.image_size, self.angle)

        #Keep the asteroid/missile on the canvas
        if self.pos[0]> width or self.pos[0]<0:
            self.pos[0] = self.pos[0] % width
        if self.pos[1]> height or self.pos[1]<0:
            self.pos[1]= self.pos[1]% height   
        
        #for explosions
        if self.animated:
            frame = self.age % self.lifespan
            center = [(frame * self.image_size[0]) + self.image_center[0], self.image_center[1]]
            canvas.draw_image(self.image, center, self.image_size, self.pos, self.image_size, self.angle)
        else:
            canvas.draw_image(self.image, self.image_center, self.image_size, self.pos, self.image_size, self.angle)
            
            
    def update(self):
        self.angle += self.angle_vel     
        self.pos[0]+=self.vel[0]
        self.pos[1]+=self.vel[1]
        self.age += 1
        
        if self.age < self.lifespan:
            return True
        else:
            return False

    def get_position(self):
        return self.pos
    
    def get_radius(self):
        return self.radius   
        
    def collide(self, other_object):  
        other_obj_pos = other_object.pos 
        other_obj_rad = other_object.radius 
        distance = dist(self.pos, other_obj_pos) 
        if distance < self.radius + other_obj_rad: 
            collide = True
            return collide
        if distance > self.radius + other_obj_rad: 
            collide = False
            return collide
        
# KEY HANDLERS

#explosion helper
def explosion_at_position(pos):
    vel = [0, 0]
    avel = 0
    explosion = Sprite(pos, vel, 0, avel, explosion_image, explosion_info, explosion_sound)
    explosion_group.add(explosion)

#checks collisions of rock + ship as well as used for rock + missile
def group_collide(group, other_object): 
    global collisions, lives, score
    collisions = 0 
    new_set = set(group) 
    for obj in new_set: 
        if obj.collide(other_object)== True: 
            group.remove(obj) 
            collisions += 1
            explosion_at_position(obj.get_position())
    return collisions

#checks collision of rock + missile
def group_group_collide(group1, group2): 
    global num_collisions, score
    num_collisions = 0
    for i in set(group2): 
        if group_collide(group1, i) > 0:
            score +=10
            group2.remove(i)                      
    return num_collisions
    # called with group1 being rocks and group2 being missiles
    # for each missile in group2 calls group_collide with group1 as first parameter and this missile as the second
    # if group_collide detects a collision, removes the missile

def reset_game():
    global lives, score,  width, height, started, missile_group, rock_group, explosion_group
    lives = 3
    score = 0          
    ship_thrust_sound.rewind()
    missile_group = set([]) 
    rock_group = set([])
    explosion_group = set([])

    
def keydown(key):
    global missile_group 
    acc_speed = .1

    if True:    

    #moves ship up & turns left or right  
        if key==simplegui.KEY_MAP["up"]:
            my_ship.image_center[0] += 90 #flame on!
            my_ship.thrust = True
            ship_thrust_sound.play()
        elif key==simplegui.KEY_MAP["left"]:
            my_ship.angle_vel -= acc_speed
        elif key==simplegui.KEY_MAP["right"]:
            my_ship.angle_vel += acc_speed

        if key==simplegui.KEY_MAP["space"]:
            my_ship.shoot()      
    
def keyup(key):
    global missile_group, fire, started
    
    if True:
        if key==simplegui.KEY_MAP["up"]:
            my_ship.image_center[0] -= 90 #flame off       
            my_ship.thrust = False
            ship_thrust_sound.pause()
        
        if key==simplegui.KEY_MAP["left"]:
            my_ship.angle_vel = 0 #stops ship from turning          

        if key==simplegui.KEY_MAP["right"]:
            my_ship.angle_vel = 0 #stops ship from turning                   
        
# mouseclick handlers that reset UI and conditions whether splash image is drawn
def click(pos):
    global started
    center = [width / 2, height / 2]
    size = splash_info.get_size()
    inwidth = (center[0] - size[0] / 2) < pos[0] < (center[0] + size[0] / 2)
    inheight = (center[1] - size[1] / 2) < pos[1] < (center[1] + size[1] / 2)
    if (not started) and inwidth and inheight:
        started = True
        reset_game()

#draws & updates rock_group to create rocks.        
def process_sprite_group(canvas, rock_group, missile_group, explosion_group):
    for rock in rock_group:
        rock.draw(canvas)
        rock.update()
    for a_missile in missile_group:
        a_missile.draw(canvas)
        ans = a_missile.update()
        if ans == False:
            missile_group.remove(a_missile)
    for explosion in explosion_group:
        explosion.draw(canvas)
        ans2 = explosion.update()
        if ans2 == False:
            explosion_group.remove(explosion)
                    
def draw(canvas):
    global time, lives, score, started, collisions, width, height, rock_group 
    
    # animiate background
    time += 1
    center = debris_info.get_center()
    size = debris_info.get_size()
    wtime = (time / 8) % center[0]
    canvas.draw_image(nebula_image, nebula_info.get_center(), nebula_info.get_size(), [width/2, height/2], [width, height])
    canvas.draw_image(debris_image, [center[0]-wtime, center[1]], [size[0]-2*wtime, size[1]], 
                                [width/2+1.25*wtime, height/2], [width-2.5*wtime, height])

    #score & lives
    canvas.draw_text(str("Lives"), [50, 50], 24, 'white')
    canvas.draw_text(str(lives), [50, 85], 24, 'white')
    canvas.draw_text(str("Score"), [680, 50], 24, 'white')
    canvas.draw_text(str(score), [680, 85], 24, 'white')   
    
    # draw ship, rocks, and missiles sprites.  Checks collisions 
    my_ship.draw(canvas) #draw ship
    my_ship.update()
    
    if started:
        timer.start()
        process_sprite_group(canvas, rock_group, missile_group, explosion_group)
        if group_collide(rock_group, my_ship):
            lives -=1
            if lives <= 0:
                started = False
                rock_group = set([])
                timer.stop()

        group_group_collide(rock_group, missile_group)
    
        # update ship and sprites
    
    # draw splash screen if not started
    if not started:
        canvas.draw_image(splash_image, splash_info.get_center(), 
                          splash_info.get_size(), [width/2, height/2], 
                          splash_info.get_size())    
            
    
# timer handler that spawns a rock with random position, velocity, and angular velocity    
def rock_spawner():
    global rock_group, width, height

    rock_turn = (random.random() * (.2-.01) + .01) *random.choice([1, -1]) #a random number between .01 <= n < .2 or -.01 <= n < -.2   
    rock_pos_x = ( my_ship.pos[0] + random.randrange( my_ship.radius*3 , width - my_ship.radius*2) ) % width #random x location for rock far from ship radius. 
    rock_pos_y = ( my_ship.pos[1] + random.randrange( my_ship.radius*3 , height - my_ship.radius*2) ) % height #random y location for rock far from ship radius.
    rock_vel_x = (random.random() * (.5-.1) + .1) *random.choice([1, -1]) #random x velocity value .1 <= n < .5 or -.1 => n > -.5.
    rock_vel_y = (random.random() * (.5-.1) + .1) *random.choice([1, -1]) #random y velocity value .1 <= n < .5 or -.1 => n > -.5.    
    
    a_rock = Sprite([rock_pos_x, rock_pos_y], [rock_vel_x, rock_vel_y], 0, rock_turn, asteroid_image, asteroid_info)

    if len(rock_group) <= 11: #will draw up to 12 rocks; lists start at zero.
        rock_group.add(a_rock)    
    
# initialize frame
frame = simplegui.create_frame("Asteroids", width, height)

# initialize ship and two sprites
my_ship = Ship([width / 2, height / 2], [0, 0], 1.5 * math.pi, ship_image, ship_info)

# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.set_mouseclick_handler(click)
timer = simplegui.create_timer(1000.0, rock_spawner)

# get things rolling
timer.start()
frame.start()



  




  

Below is a screenshot of it in action:

Classic Pong (Coded in Python)

  
    
# Implementation of classic arcade game Pong

import simplegui
import random

# initialize globals - pos and vel encode vertical info for paddles
WIDTH = 600
HEIGHT = 400       
BALL_RADIUS = 20
PAD_WIDTH = 8
PAD_HEIGHT = 80
HALF_PAD_WIDTH = PAD_WIDTH / 2
HALF_PAD_HEIGHT = PAD_HEIGHT / 2

ball_pos = [WIDTH / 2, HEIGHT / 2] 
ball_vel = [((-1) ** random.randrange(2)) * random.randrange(1,4), -1 * random.randrange(1,3)]

## if you replace the top with this code, it will randomize the y axis as well.  
## however, due to the rubric, it was removed.
## ball_vel = [((-1) ** random.randrange(2)) * random.randrange(1,4), ((-1) ** random.randrange(2)) * random.randrange(1,3)]


paddle1_pos = [4, 40]
paddle1_vel = [0, 0]
paddle2_pos = [596 , 40]
paddle2_vel = [0, 0]

score1 = 0
score2 = 0


# helper function that spawns a ball, returns a position vector and a velocity vector
# if right is True, spawn to the right, else spawn to the left
def ball_init(right):
    global ball_pos, ball_vel # these are vectors stored as lists
    ball_pos = [WIDTH / 2, HEIGHT / 2]
    if right == True:
        ball_vel = [random.randrange(1, 4), -1 * random.randrange(1,3)]
    elif right == False:	
        ball_vel = [ -1 * random.randrange(1,4), -1 * random.randrange(1,3)]
  
    #if you replace the top with this code, it will randomize the y-axis as well.  
    #However, due to the rubric of always needing to start up, it was removed
    #if right == True:
        #ball_vel = [random.randrange(1, 4), ((-1) ** random.randrange(2)) * random.randrange(1,3)]
    #elif right == False:	
        #ball_vel = [ -1 * random.randrange(1,4), ((-1) ** random.randrange(2)) * random.randrange(1,3)]

# define event handlers
def init():
    global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel  # these are floats
    global score1, score2  # these are ints
    score1 = 0
    score2 = 0
    pass

def update_paddle1(): #prevents top left panel from spilling by going too high
    global paddle1_pos 
    # Will this movement increment still have us on the screen 
    if (paddle1_pos[1] - (PAD_HEIGHT / 2)) - paddle1_vel[1] >= 0: 
    # Yes - then move the paddle
        paddle1_vel[1] 
    else: 
    # No - then the paddle velocity should stop and set paddle position to be at the top of screen 
        paddle1_pos[1] = PAD_HEIGHT / 2 
        paddle1_vel[1] = 0

def update_paddle2(): #prevents top right panel from spilling by going too high
    global paddle2_pos 
    # Will this movement increment still have us on the screen 
    if (paddle2_pos[1] - (PAD_HEIGHT / 2)) - paddle2_vel[1] >= 0: 
    # Yes - then move the paddle
        paddle2_vel[1] 
    else: 
    # No - then the paddle velocity should stop and set paddle position to be at the top of screen 
        paddle2_pos[1] = PAD_HEIGHT / 2 
        paddle2_vel[1] = 0        

def update_paddle3(): #prevent left panel from spilling by going too low
    global paddle1_pos 
    # Will this movement increment still have us on the screen 
    if (paddle1_pos[1] + (PAD_HEIGHT / 2)) + paddle1_vel[1] <= 400: 
    # Yes - then move the paddle
        paddle1_vel[1] 
    else: 
    # No - then the paddle velocity should stop and set paddle position to be at the top of screen 
        paddle1_pos[1] = 400 - PAD_HEIGHT / 2 
        paddle1_vel[1] = 0        

def update_paddle4(): #prevent right panel from spilling by going too low
    global paddle2_pos 
    # Will this movement increment still have us on the screen 
    if (paddle2_pos[1] + (PAD_HEIGHT / 2)) + paddle2_vel[1] <= 400: 
    # Yes - then move the paddle
        paddle2_vel[1] 
    else: 
    # No - then the paddle velocity should stop and set paddle position to be at the top of screen 
        paddle2_pos[1] = 400 - PAD_HEIGHT / 2 
        paddle2_vel[1] = 0                
        
        
def draw(canvas):
    global score1, score2, paddle1_pos, paddle2_pos, ball_pos, ball_vel

    
    # draw mid line and gutters
    canvas.draw_line([WIDTH / 2, 0],[WIDTH / 2, HEIGHT], 1, "White")
    canvas.draw_line([PAD_WIDTH, 0],[PAD_WIDTH, HEIGHT], 1, "White")
    canvas.draw_line([WIDTH - PAD_WIDTH, 0],[WIDTH - PAD_WIDTH, HEIGHT], 1, "White")

    #draw score card
    canvas.draw_text(str(score1), [40, 30], 24, 'white')
    canvas.draw_text(str(score2), [550, 30], 24, 'white')

    
    # left paddle position & velocity
    paddle1_pos[1] += paddle1_vel[1]   
    canvas.draw_line([paddle1_pos[0],paddle1_pos[1]-HALF_PAD_HEIGHT],[paddle1_pos[0],paddle1_pos[1]+HALF_PAD_HEIGHT], PAD_WIDTH, "white")
    
    # right paddle position & velocity
    paddle2_pos[1] += paddle2_vel[1]
    canvas.draw_line([paddle2_pos[0],paddle2_pos[1]-HALF_PAD_HEIGHT],[paddle2_pos[0],paddle2_pos[1]+HALF_PAD_HEIGHT], PAD_WIDTH, "white")
    
    # update ball

    ball_pos[0] += ball_vel[0]
    ball_pos[1] += ball_vel[1]

    # update paddle's vertical position, keep paddle on the screen
    update_paddle1()
    update_paddle2()
    update_paddle3()
    update_paddle4()
    
    #this code will  tests whether the ball touches/collides 
    #with the left and right screen

    #this code will  tests whether the ball touches/collides 
    #with the left and right screen
    if ball_pos[0] < PAD_WIDTH + BALL_RADIUS: #this touches left
        if ball_pos[1] >= paddle1_pos[1]- HALF_PAD_HEIGHT and ball_pos[1] <= paddle1_pos[1] + HALF_PAD_HEIGHT:
            ball_vel[0] = - 1.1 * ball_vel[0]
        else:
            ball_init(True)
            score2 += 1
        
    if ball_pos[0] > (WIDTH - PAD_WIDTH - 1) - BALL_RADIUS: #this touches right
        if ball_pos[1] >= paddle2_pos[1]- HALF_PAD_HEIGHT and ball_pos[1] <= paddle2_pos[1] + HALF_PAD_HEIGHT:
            ball_vel[0] = - 1.1 * ball_vel[0]
        else:
            ball_init(False)
            score1 += 1
        
    #this code will bounce ball off the top & bottom of the screen
    if ball_pos[1] <= BALL_RADIUS:
        ball_vel[1] = - ball_vel[1]
    if ball_pos[1] >= (HEIGHT - 1) - BALL_RADIUS:
        ball_vel[1] = - ball_vel[1]    
    
    # draw ball and scores
    canvas.draw_circle(ball_pos, BALL_RADIUS, 2, "Red", "White")

    
def keydown(key):
    global paddle1_vel, paddle2_vel
    acc = 5
    #moves left paddle up and down
    if key==simplegui.KEY_MAP["s"]:
        paddle1_vel[1] = acc
    if key==simplegui.KEY_MAP["w"] and paddle1_pos[1] > 40:
        paddle1_vel[1] -= acc      
        
    #moves right paddle up and down    
    if key==simplegui.KEY_MAP["down"]:
        paddle2_vel[1] += acc
    elif key==simplegui.KEY_MAP["up"]:
        paddle2_vel[1] -= acc

    
    
def keyup(key):
    global paddle1_vel, paddle2_vel
    acc = 0
    #moves left paddle up and down
    if key!=simplegui.KEY_MAP["s"]:
        paddle1_vel[1] = 0
    elif key!=simplegui.KEY_MAP["w"]:
        paddle1_vel[1] = 0
    
    #moves right paddle up and down    
    if key!=simplegui.KEY_MAP["down"]:
        paddle2_vel[1] = 0
    elif key!=simplegui.KEY_MAP["up"]:
        paddle2_vel[1] = 0

def restart():
    global ball_pos, ball_vel, score1, score2
    score1 = 0
    score2 = 0
    ball_pos = [WIDTH / 2, HEIGHT / 2] 
    ball_vel = [((-1) ** random.randrange(2)) * random.randrange(1,4), -1 * random.randrange(1,3)]

    #if you replace the top with this code, it will randomize the y-axis as well.  
    #However, due to the rubric of always needing to start up, it was removed
    ## ball_vel = [((-1) ** random.randrange(2)) * random.randrange(1,4), ((-1) ** random.randrange(2)) * random.randrange(1,3)]

        
# create frame
frame = simplegui.create_frame("Pong", WIDTH, HEIGHT)
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.add_button("Restart", restart, 100)


# start frame
init()
frame.start()
restart()



  




  

Memory Game (coded in Python)

  
    

# implementation of card game - Memory

import simplegui
import random

cards = range(8) + range(8)
exposed_list = [False] * 16
WIDTH = 50
HEIGHT = 100
i = 0
CANVAS_WIDTH = 800
CANVAS_HEIGHT = 100
CARD_WIDTH = 50
click1 = 0
click2 = 0
moves = 0

CARD_HEIGHT = 110 # set height of cards
CARD_WIDTH = 110 # set width of cards
ROW = 4 # set number of roes in the grid
COL = 4 # set number of columns in the grid
BORDER = 3 # set card border dimension


# images:
theme = {0:"http://i.imgur.com/MM9V4.jpg",
        1:"http://i.imgur.com/uLSe6.jpg",
        2:"http://i.imgur.com/m9eLa.jpg",
        3:"http://i.imgur.com/z6xcF.jpg",
        4:"http://i.imgur.com/sUtbV.jpg",
        5:"http://i.imgur.com/yyyRG.jpg",
        6:"http://i.imgur.com/4Wydt.jpg",
        7:"http://i.imgur.com/iDpPK.jpg",
        "colors": ["Silver", "teal"]
        }

# default theme
card_theme = theme

# helper function to initialize globals
def init():
    global state, click1, click2, exposed_list, moves
    state = 0
    click1 = 0
    click2 = 0
    random.shuffle(cards)
    moves = 0
    exposed_list = [False] * 16
     
# define event handlers
def mouseclick(pos):
    global state, click1, click2, moves
    idx = int(list(pos)[0]/CARD_WIDTH) + COL*int(list(pos)[1]/CARD_HEIGHT)    
    
    #if blank box (exposed_list == False)
    if exposed_list[idx] == False: 
        if state == 0:
            state = 1
            exposed_list[idx] = True #flip first card
            click1 = idx #add value first click to click1
            moves += 1
                        
        elif state == 1:
            state = 2
            exposed_list[idx] = True #flip second card
            click2 = idx #add value second click to click2
            
        elif state == 2: 
            #if value first click & second click doesn't equal each other,
            #unflip cards
            if cards[click1] != cards[click2]:
                exposed_list[click1] = False
                exposed_list[click2] = False
                state = 1   
                exposed_list[idx] = True
                click1 = idx
            #if value of first click & second click equal each other,
            #keep cards exposed
            if cards[click1] == cards[click2]:
                state = 1   
                click1 = idx
                exposed_list[click1] = True 
                click2 = 0
            moves += 1
                     
    if exposed_list[idx] == True: #do nothing if card is exposed
        return
    
# cards are logically 50x100 pixels in size    
def draw(canvas):  
    label.set_text("Moves = " + str(moves))
def draw(canvas):
    """Draws card in a 4 x 4 grid mapping elements of the deck list like this :

                    COL
              0	   1    2    3		We have a 4x4 grid in which we make correspond
            ---------------------   an index of the deck list for each pair of (row,col)
          0 |  0 |  1 | 2  | 3  |	coordinates. So that at (1,3) we have the index 7
     R       ---------------------	in the deck list which contains the card.
     O    1 |  4 |  5 | 6  | 7  |	
     W      ---------------------	So first we compute the corresponding (row,col)
          2 |  8 |  9 | 10 | 11 |	coordinate for the index and then we use them to
            ---------------------	draw cards in their spot on the canvas.
          3 | 12 | 13 | 14 | 15 |
            ---------------------
    """
    count = 0	# use count as index for deck list
    for n in cards:
        # computing : index -> (row, col) coordinate in the grid
        row = int(count/COL)
        col = count%COL
        # computing centre of image from (row,col)
        position = [CARD_WIDTH/2 + col*CARD_WIDTH, CARD_HEIGHT/2+(row*CARD_HEIGHT)]
        # load image exploiting a dictionary
        image = simplegui.load_image(card_theme[cards[count]])
        
        
        # read dimension of the image
        w = 300
        h = 300
        #draws card in the proper position
        canvas.draw_image(image,[w/2, h/2],[w,h],position,[CARD_WIDTH,CARD_HEIGHT])
        # expose / unexpose cards
        if not exposed_list[count]:
            a = [col*CARD_WIDTH,row*CARD_HEIGHT]
            b = [CARD_WIDTH*(1+col), row*CARD_HEIGHT]
            c = [CARD_WIDTH*(1+col),CARD_HEIGHT*(1+row)]
            d = [col*CARD_WIDTH,CARD_HEIGHT*(1+row)]
            canvas.draw_polygon([a,b,c,d],BORDER,card_theme["colors"][0],card_theme["colors"][1])
        count += 1
    label.set_text("Moves = " + str(moves))
if ROW*COL > (len(theme)-1)*2:
    print "Error: the size of the image dictionary\nis to small to show a",ROW,"x",COL,"grid!"
elif (ROW*COL)%2 != 0:
     print "Error: number of cards must be an even number!"
    
# create frame and add a button and labels
frame = simplegui.create_frame("Memory", CARD_WIDTH*COL, CARD_HEIGHT*ROW)
frame.add_button("Restart", init,100)
frame.add_label("")
label = frame.add_label("Label")

# initialize game
init()

# register event handlers
frame.set_canvas_background("White")
frame.set_mouseclick_handler(mouseclick)
frame.set_draw_handler(draw)
# get things rolling
frame.start()



# Always remember to review the grading rubric

  




  