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

  




  
  

Coding

Coloring Book (Built with Processing)

Asteroids (Coded in Python)

Classic Pong (Coded in Python)

Memory Game (coded in Python)

Gotham Font Meets Gotham