# 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 LEFT = False RIGHT = True PAD1_X = HALF_PAD_WIDTH PAD2_X = WIDTH-HALF_PAD_WIDTH PAD_VEL = 400.0/60.0 # the paddles vertical constant velocity BALL_VEL_MUL = 1.1 # increase the speed of the ball by 10% every hit FONT_SIZE = 40 # Score font size # initialize ball_pos and ball_vel for new bal in middle of table # if direction is RIGHT, the ball's velocity is upper right, else upper left def spawn_ball(direction): global ball_pos, ball_vel # these are vectors stored as lists # set the ball initial position to the center ball_pos = [WIDTH / 2, HEIGHT / 2] # generate random values for the horizontal and vertical velocity hor_vel = float(random.randrange(120, 240)) ver_vel = float(random.randrange(60, 180)) # set the velocity according to the direction if direction==RIGHT: # Upper Right ball_vel = [ hor_vel/ 60.0, -ver_vel/ 60.0] else: # Upper Left ball_vel = [ -hor_vel/ 60.0, -ver_vel/ 60.0] # define event handlers def new_game(): global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel # these are numbers global score1, score2 # these are ints # spawn ball to a random direction dir = random.choice([LEFT, RIGHT]) spawn_ball(dir) # set left, right paddles position to the vertical middle # the position is of the top of the paddle paddle1_pos = HEIGHT/2 - HALF_PAD_HEIGHT paddle2_pos = HEIGHT/2 - HALF_PAD_HEIGHT # set the initial vertical velocity of the paddle to 0 paddle1_vel = paddle2_vel = 0 # init player1, player2 score to 0 score1 = score2 = 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") # update ball position ball_pos[0] += ball_vel[0] ball_pos[1] += ball_vel[1] # check collision in the top or bottom if (ball_pos[1] <= BALL_RADIUS) or (ball_pos[1] >= HEIGHT-1-BALL_RADIUS): ball_vel[1] = - ball_vel[1] # check collision to the left spawn ball to the right if miss if (ball_pos[0] <= PAD_WIDTH+BALL_RADIUS): # ball touching left, check if touches the left paddle if (ball_pos[1]>=paddle1_pos) and (ball_pos[1]<=paddle1_pos+PAD_HEIGHT): # reflect the ball and increase ball velocity # x velocity both negate and multiplied, y velocity multiplied ball_vel[0] *= -BALL_VEL_MUL ball_vel[1] *= BALL_VEL_MUL else: # miss on left, spawn ball to the right, right gets a point spawn_ball(RIGHT) score2 += 1 # check collision to the right spawn ball to the left if miss if (ball_pos[0] >= WIDTH-PAD_WIDTH-BALL_RADIUS): # ball touching right, check if touches the right paddle if (ball_pos[1]>=paddle2_pos) and (ball_pos[1]<=paddle2_pos+PAD_HEIGHT): # reflect the ball and increase ball velocity # x velocity both negate and multiplied, y velocity multiplied ball_vel[0] *= -BALL_VEL_MUL ball_vel[1] *= BALL_VEL_MUL else: # miss on right, spawn ball to the left, left gets a point spawn_ball(LEFT) score1 += 1 # draw ball canvas.draw_circle(ball_pos, BALL_RADIUS, 1, "White", "White") # update paddle's vertical position, keep paddle on the screen paddle1_pos += paddle1_vel paddle2_pos += paddle2_vel # check if paddle exit the canvas, keep it in the canvas area if paddle1_pos < 0: paddle1_pos = 0 if paddle1_pos > HEIGHT-1-PAD_HEIGHT: paddle1_pos = HEIGHT-1-PAD_HEIGHT if paddle2_pos < 0: paddle2_pos = 0 if paddle2_pos > HEIGHT-1-PAD_HEIGHT: paddle2_pos = HEIGHT-1-PAD_HEIGHT # draw paddles - using draw line with paddle width canvas.draw_line([PAD1_X, paddle1_pos], [PAD1_X,paddle1_pos+PAD_HEIGHT], PAD_WIDTH, "White") canvas.draw_line([PAD2_X, paddle2_pos], [PAD2_X,paddle2_pos+PAD_HEIGHT], PAD_WIDTH, "White") # draw scores canvas.draw_text(str(score1), (int(WIDTH*0.25), 40), FONT_SIZE, "White", "monospace") canvas.draw_text(str(score2), (int(WIDTH*0.75), 40), FONT_SIZE, "White", "monospace") def keydown(key): global paddle1_vel, paddle2_vel if key==simplegui.KEY_MAP["down"]: paddle2_vel = PAD_VEL elif key==simplegui.KEY_MAP["up"]: paddle2_vel = -PAD_VEL if key==simplegui.KEY_MAP["s"]: paddle1_vel = PAD_VEL elif key==simplegui.KEY_MAP["w"]: paddle1_vel = -PAD_VEL def keyup(key): global paddle1_vel, paddle2_vel if key==simplegui.KEY_MAP["down"]: paddle2_vel = 0 elif key==simplegui.KEY_MAP["up"]: paddle2_vel = 0 if key==simplegui.KEY_MAP["s"]: paddle1_vel = 0 elif key==simplegui.KEY_MAP["w"]: paddle1_vel = 0 def but_reset(): new_game() # create frame frame = simplegui.create_frame("Pong", WIDTH, HEIGHT) frame.set_draw_handler(draw) frame.set_keydown_handler(keydown) frame.set_keyup_handler(keyup) but_reset_h = frame.add_button('Restart', but_reset, 100) # start frame new_game() frame.start() # "Stopwatch: The Game" # imports import simplegui # define global variables CANVAS_SIZE = [500 , 150] FONT_SIZE = 40 # Timer font size ST_FONT_SIZE = 20 # Stop/Success font size cur_time = 0 # a counter of tenth of sec timer_running = False # indicates if timer is running num_stop_pressed = 0 # keep the num of stop button clicks num_success = 0 # keep the num of stop in round sec # define helper function format that converts time # in tenths of seconds into formatted string A:BC.D def format(counter): """ This function gets a counter in tenth of sec and convert it to a string containing the time format """ # first get the minuts - counter / 10 / 60 mint = counter // 600 rem = counter % 600 # get the first sec digit - rem / 10 / 10 sec1 = rem // 100 rem = rem % 100 # get the 2nd sec digit - rem / 10 sec2 = rem // 10 rem = rem % 10 # get tenth sec digit tsec = rem return str(mint)+":"+str(sec1)+str(sec2)+"."+str(tsec) # Event handler for start button def but_start(): global timer, timer_running if not timer_running: timer.start() timer_running = True # helper function to check stop success def check_success(): """ check the success of the current timer This function is checked when stop buttom pressed return 1 on success, 0 otherwise """ global cur_time if (cur_time % 10) == 0: return 1 else: return 0 # Event handler for stop button def but_stop(): global timer, timer_running, num_stop_pressed, num_success if timer_running: timer.stop() timer_running = False num_stop_pressed += 1 num_success += check_success() #print str(num_success)+"/"+str(num_stop_pressed) # Event handler for reset button def but_reset(): global cur_time, timer, timer_running, num_stop_pressed, num_success timer.stop() cur_time = 0 timer_running = False num_stop_pressed = 0 num_success = 0 # define event handler for timer with 0.1 sec interval def update(): """ This is the timer handler called every 100 msec It increment the cur_time by 1 each tick """ global cur_time #print cur_time # for testing purpose cur_time +=1 # define draw handler def draw(canvas): global cur_time # draw the formatted timer canvas.draw_text(format(cur_time), (100, CANVAS_SIZE[1]/2+ FONT_SIZE/4), FONT_SIZE, "Red", "monospace") # draw stop and success rates stop_success_str = str(num_success)+"/"+str(num_stop_pressed) canvas.draw_text(stop_success_str, (CANVAS_SIZE[0]-ST_FONT_SIZE*len(stop_success_str), 25), ST_FONT_SIZE, "Yellow", "monospace") # create frame frame = simplegui.create_frame("Stopwatch: The Game", CANVAS_SIZE[0], CANVAS_SIZE[1]) # register event handlers frame.set_draw_handler(draw) frame.set_canvas_background("Black") # create buttons: Start, Stop, Reset but_start_h = frame.add_button('Start', but_start, 50) but_stop_h = frame.add_button('Stop', but_stop, 50) but_reset_h = frame.add_button('Reset', but_reset, 50) # set timer to tick every 0.1 sec = 100 msec timer = simplegui.create_timer(100, update) # start frame frame.start() # "Guess the number" mini-project # input will come from buttons and an input field # all output for the game will be printed in the console import random import simplegui import math # initialize global variables used in your code secret_number = 0 # the secret number the computer guesses game_range = 100 # what is the range of numbers to guess remaining_guesses = 7 # how many guesses are available # helper function to start and restart the game def new_game(): """ This function initializeds the variables of the game by selecting a new random secret number in the desired range and initiate the remaining guesses """ global secret_number, game_range, remaining_guesses # Generate a random secret number follow the Python convention of [low, high) secret_number = random.randrange(0, game_range) # Compute the number of available guesses by log2(range) routed up remaining_guesses = int(math.ceil(math.log(game_range, 2))) print print "========= New Game =========" print "Guess a number between 0 and", game_range print "You have " + str(remaining_guesses) + " guesses" # define event handlers for control panel def range100(): # button that changes range to range [0,100) and restarts global game_range game_range = 100 new_game() def range1000(): # button that changes range to range [0,1000) and restarts global game_range game_range = 1000 new_game() # helper function to get and check the guess string def get_check_guess(guess): """ This function get the string guess and check that it's an int number It convert the number to int or print an error message if it's not int The function allows any positive int number, for non int it returns 0 """ if guess.isdigit(): return int(guess) else: print "Error: Number must be a positive integer. Using 0 instead" return 0 # helper function to check and update remaining guesses def chk_upd_remaining_guesses(): """ This function decrement the remaining guesses and check if more guesses are available. If not it starts a new game """ global remaining_guesses, secret_number if remaining_guesses <=1: print "Sorry, you have no gueeses left." print "The number is",secret_number print "Try a new Game." new_game() else: remaining_guesses -= 1 print "Remaining guesses:",remaining_guesses def input_guess(guess): """ This function is the input guess handler function It get the user guess and check against the secret number """ global remaining_guesses, secret_number # Convert the entered string guess into number user_guess = get_check_guess(guess) print "You chose:",user_guess if user_guess > secret_number: print "Your guess is higher" elif user_guess < secret_number: print "Your guess is lower" else: print "Great!!! Your guess is correct!" new_game() return # print extra line between guesses print # Check and update remaining guesses chk_upd_remaining_guesses() # create frame frame = simplegui.create_frame("Guess the number", 300, 200) # register event handlers for control elements inp = frame.add_input("Your Guess", input_guess, 200) frame.add_button("Range: 0 - 100", range100, 200) frame.add_button("Range: 0 - 1000", range1000, 200) # call new_game and start frame new_game() frame.start() # implementation of card game - Memory import simplegui import random NUM_PAIRS = 8 CARD_SIZE = [50,100] # size x, size y of a card FONT_SIZE = 40 FONT_COLOR = "White" FONT_FACE = "monospace" CARD_COLOR = "Green" CARD_BORDER_COLOR = "Brown" # helper function to initialize globals def new_game(): global card_list, exposed, card1, card2, state, turns # generate a list that contain [0:8) numbers twice card_list = range(NUM_PAIRS) card_list.extend(range(NUM_PAIRS)) random.shuffle(card_list) #print card_list # at startup all cards are closed exposed = [False for i in range(NUM_PAIRS*2)] state = 0 # the sate of the game: 0-no card exposed, 1-one card, 2-two cards card1 = card2 = 0 # the cards number clicked turns = 0 label.set_text("Turns = " + str(turns)) # define event handlers def mouseclick(pos): global card_list, exposed, state, turns, card1, card2 # convert pos to card_num card_num = pos[0] // CARD_SIZE[0] if state == 0: exposed[card_num] = True # in state 0 just expose the card card1 = card_num # keep first card state = 1 elif state == 1: if not exposed[card_num]: # we clicked on a close card on state 1 exposed[card_num] = True # expose it card2 = card_num # keep second card turns +=1 # increment turns label.set_text("Turns = " + str(turns)) state = 2 else: if not exposed[card_num]: # we clicked on a close card on state 2 # check if card1, card 2 don't have the same value close them if not card_list[card1] == card_list[card2]: exposed[card1]=exposed[card2]=False exposed[card_num] = True # expose it state = 1 # go back to state 1 card1 = card_num # keep first card # helper function to draw open card number on screen def draw_card_open(canvas, card_num): canvas.draw_text(str(card_list[card_num]), (card_num*CARD_SIZE[0]+(CARD_SIZE[0]-FONT_SIZE/2)/2, 60), FONT_SIZE, FONT_COLOR, FONT_FACE) # helper function to draw closed card number on screen def draw_card_closed(canvas, card_num): canvas.draw_polygon([[card_num*CARD_SIZE[0],0], [(card_num+1)*CARD_SIZE[0]-1, 0], [(card_num+1)*CARD_SIZE[0]-1, CARD_SIZE[1]], [card_num*CARD_SIZE[0], CARD_SIZE[1]]], 3, CARD_BORDER_COLOR, CARD_COLOR) # cards are logically 50x100 pixels in size def draw(canvas): global card_list, exposed # print the numbers on the canvas for card_num in range(len(card_list)): if exposed[card_num]: draw_card_open(canvas, card_num) else: draw_card_closed(canvas, card_num) # create frame and add a button and labels frame = simplegui.create_frame("Memory", 2*CARD_SIZE[0]*NUM_PAIRS, CARD_SIZE[1]) frame.add_button("Reset", new_game) label = frame.add_label("Turns = 0") # register event handlers frame.set_mouseclick_handler(mouseclick) frame.set_draw_handler(draw) # get things rolling new_game() frame.start() # Mini-project #6 - Blackjack import simplegui import random # load card sprite - 949x392 - source: jfitz.com CARD_SIZE = (73, 98) CARD_CENTER = (36.5, 49) card_images = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/cards.jfitz.png") CARD_BACK_SIZE = (71, 96) CARD_BACK_CENTER = (35.5, 48) card_back = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/card_back.png") # initialize some useful global variables in_play = False outcome = "" status = "" score = 0 # define globals for cards SUITS = ('C', 'S', 'H', 'D') RANKS = ('A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K') VALUES = {'A':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9, 'T':10, 'J':10, 'Q':10, 'K':10} # define card class class Card: def __init__(self, suit, rank): if (suit in SUITS) and (rank in RANKS): self.suit = suit self.rank = rank else: self.suit = None self.rank = None print "Invalid card: ", suit, rank def __str__(self): return self.suit + self.rank def get_suit(self): return self.suit def get_rank(self): return self.rank def draw(self, canvas, pos): card_loc = (CARD_CENTER[0] + CARD_SIZE[0] * RANKS.index(self.rank), CARD_CENTER[1] + CARD_SIZE[1] * SUITS.index(self.suit)) canvas.draw_image(card_images, card_loc, CARD_SIZE, [pos[0] + CARD_CENTER[0], pos[1] + CARD_CENTER[1]], CARD_SIZE) # define hand class class Hand: def __init__(self): self.card_list = [] def __str__(self): str = "Hand contains" for card in self.card_list: str += " " + card.get_suit() + card.get_rank() return str def add_card(self, card): self.card_list.append(card) def get_value(self): # count aces as 1, if the hand has an ace, then add 10 to hand value if it doesn't bust value = 0 has_aces = False for card in self.card_list: value += VALUES[card.get_rank()] if card.get_rank() == 'A': has_aces = True if has_aces: if value + 10 <= 21: value+=10 return value def draw(self, canvas, pos): delta = 0 max_card = min(6,len(self.card_list)) # draw up to 6 cards for card in self.card_list[0:max_card]: card.draw(canvas, [pos[0]+delta, pos[1]]) delta += CARD_SIZE[0] + 10 # define deck class class Deck: def __init__(self): self.cards = [] for suit in SUITS: self.cards += [Card(suit,rank) for rank in RANKS] def shuffle(self): # shuffle the deck random.shuffle(self.cards) def deal_card(self): if len(self.cards) > 0: return self.cards.pop() else: return 0 print "Warning: Trying to deal a card from an empty deck" def __str__(self): str = "Deck contains" for card in self.cards: str += " " + card.get_suit() + card.get_rank() return str #define event handlers for buttons def deal(): global outcome, in_play, deck, player_hand, dealer_hand, status, score # initialize deck and shuffle deck = Deck() deck.shuffle() # initialize player, dealer hands, deal two cards for each player_hand = Hand() dealer_hand = Hand() for i in range(2): player_hand.add_card(deck.deal_card()) dealer_hand.add_card(deck.deal_card()) if in_play: # Clicking deal in the middle of the game status = "You lost." score -=1 else: status = "New deal." outcome = "Hit or stand?" in_play = True def hit(): global outcome, in_play, deck, player_hand, score, status # if the hand is in play, hit the player if in_play: player_hand.add_card(deck.deal_card()) # if busted, assign a message to outcome, update in_play and score if player_hand.get_value() > 21: in_play = False outcome = "New deal?" status = "You went bust and lose." score -= 1 def stand(): global outcome, in_play, deck, player_hand, dealer_hand, score, status # if hand is in play, repeatedly hit dealer until his hand has value 17 or more if in_play: if player_hand.get_value() > 21: # Player have been busted, decrement score status = "You went bust and lose." score -=1 else: while dealer_hand.get_value() < 17: dealer_hand.add_card(deck.deal_card()) if dealer_hand.get_value() > 21: # Dealer have been busted, increment score status = "Went bust, you won." score += 1 else: if player_hand.get_value() <= dealer_hand.get_value(): # Dealer Wins! status = "You lost." score -=1 else: # Player Wins! status = "You won." score +=1 in_play = False outcome = "New deal?" # draw handler def draw(canvas): global outcome, in_play, player_hand, dealer_hand, score, status canvas.draw_text("Blackjack", (80,100), 40, "Aqua", "sans-serif") canvas.draw_text("Dealer", (60,180), 30, "Black", "sans-serif") canvas.draw_text("Player", (60,350), 30, "Black", "sans-serif") canvas.draw_text(outcome, (250, 350), 30, "Black", "sans-serif") canvas.draw_text("Score "+str(score), (400,100), 30, "Black", "sans-serif") canvas.draw_text(status, (250,180), 30, "Black", "sans-serif") dealer_hand.draw(canvas, [60, 200]) player_hand.draw(canvas, [60, 370]) # if in play draw back card on dealer first card if in_play: canvas.draw_image(card_back, CARD_BACK_CENTER, CARD_BACK_SIZE, [61 + CARD_BACK_CENTER[0], 201 + CARD_BACK_CENTER[1]], CARD_BACK_SIZE) # initialization frame frame = simplegui.create_frame("Blackjack", 600, 600) frame.set_canvas_background("Green") #create buttons and canvas callback frame.add_button("Deal", deal, 200) frame.add_button("Hit", hit, 200) frame.add_button("Stand", stand, 200) frame.set_draw_handler(draw) # get things rolling deal() frame.start() # program template for Spaceship import simplegui import math import random # --------------- globals for user interface ---------------# WIDTH = 800 HEIGHT = 600 SCREEN_SIZE = [WIDTH, HEIGHT] # --------------------- global constants -------------------# FRAME_RATE = 60.0 # draw frame rate NUM_DIMENSIONS = 2 # used for looping dimentions FRICTION_CONST = 0.05 # amount of ship velocity reduction due to friction SHIP_ACC = 20/FRAME_RATE # amount of ship acceleration when thrust SHIP_ANG_VEL = 3/FRAME_RATE # ship rotation velocity when left/right arrow pressed ROCK_SP_MARGIN = 10 # screen edge position margin not allowed for rock spawn ROCK_SHIP_MARGIN = 50 # margin from spawn rock to ship ROCK_MIN_VEL = 10 # min, max rock velocity range ROCK_MAX_VEL = 60 ROCK_MIN_ANG_VEL = 1 # min, max rock angular velocity range ROCK_MAX_ANG_VEL = 3 MAX_ROCKS = 12 # max number of rocks allowed on a given time MISSILE_FWD_MUL = 5 # missile velocity multiplier of ship forward dir MAX_LIVES = 3 # number of lives game starts with SCORE_VEL_MUL = 0.05 # increase of rock velocity based on score EXPLOSION_RATE = FRAME_RATE # frame rate to animate explosion # --------------------- ImageInfo Class -------------------# """ Used to manage the images loaded """ class ImageInfo: def __init__(self, center, size, radius = 0, lifespan = None, animated = False, tile_size = [1,1]): self.center = center self.size = size self.radius = radius if lifespan: self.lifespan = lifespan else: self.lifespan = float('inf') self.animated = animated self.tile_size = tile_size 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 def get_tile_size(self): return self.tile_size # 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) # ----------------------- Sprite Class --------------------# """ Used to handle sprite movements, sounds, costume, collisions, etc. on the screen """ 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.tile_size = info.get_tile_size() self.costume_idx = 0 # start with costume 0 self.age = 0 self.sound = sound self.acc = 0 # default sprite have no acceleration self.friction = 0 # no friction in default self.animate_time = 0.0 self.animate_rate = 0.0 # set the costume image of a given index def set_costume(self, index): self.costume_idx = index # animate the costume images at rate <rate>, rate=0 to stop animating def animate(self, rate): if self.animated: self.animate_rate = rate self.animate_time = 0.0 # play sound def play_sound(self, play, rewind=True): if self.sound: if rewind: self.sound.rewind() if play: self.sound.play() else: self.sound.pause() def draw(self, canvas): # draw the right costume # when animating, increment the index by animated time draw_index = [((self.animate_time+self.costume_idx) % self.tile_size[0]) // 1, (((self.animate_time+self.costume_idx) // self.tile_size[0]) % self.tile_size[1]) // 1] center = [self.image_center[0] + draw_index[0] * self.image_size[0], self.image_center[1] + draw_index[1] * self.image_size[1]] canvas.draw_image(self.image, center, self.image_size, self.pos, self.image_size, self.angle) def set_angle_vel(self, vel): self.angle_vel = vel # Set the forward acceleration. No angular acc for now. def set_acc(self, acc): self.acc = acc def set_friction(self, friction): self.friction = friction def get_pos(self): return self.pos def get_vel(self): return self.vel def get_radius(self): return self.radius def is_aged(self): # if lifesppan set to None, no age of sprite if not self.lifespan: return False # otherwise return true if if age >= lifespan return (self.age>self.lifespan) # check collision with another sprite def collide(self, another_sprite): if dist(self.pos, another_sprite.get_pos()) < self.radius+another_sprite.get_radius(): return True # collission else: return False # no collission def update(self, screen_wrap = True): # calc the acceleratio vector forward = angle_to_vector(self.angle) for i in range(NUM_DIMENSIONS): # update position self.pos[i] += self.vel[i] if screen_wrap: self.pos[i] %= SCREEN_SIZE[i] # update velocity due to friction, no change if friction = 0 self.vel[i]*=(1-self.friction) # update velocity due to acceleration, no change if acc = 0 self.vel[i]+=self.acc*forward[i] # calc the rotation, for now only constant velocity self.angle += self.angle_vel # update age every time update is called, assume calling at const rate self.age +=1 # update animate time, if rate=0 no update in time self.animate_time += self.animate_rate/FRAME_RATE # ----------------------- Ship Class ----------------------# """ Ship is a special Sprite that handle ship logic Inherite from Sprite """ class Ship(Sprite): def __init__(self, pos, vel, ang, image, info, sound = None): Sprite.__init__(self, pos, vel, ang, 0, image, info, sound) Sprite.set_friction(self, FRICTION_CONST) self.thrust = False def set_thrust(self, on): self.thrust = on Sprite.play_sound(self, on, True) if on: Sprite.set_acc(self, SHIP_ACC) Sprite.set_costume(self, 1) else: Sprite.set_acc(self, 0) Sprite.set_costume(self, 0) def shoot(self): global missile_group forward = angle_to_vector(self.angle) # missile position is the tip of the ship cannon pos = [self.pos[0] + (5+self.radius) * forward[0], self.pos[1] + (5+self.radius) * forward[1]] # missile velocity is the sum of ship vel + mult of forward vect vel = [self.vel[0] + MISSILE_FWD_MUL * forward[0], self.vel[1] + MISSILE_FWD_MUL * forward[1]] a_missile = Sprite(pos, vel, 0, 0, missile_image, missile_info, missile_sound) missile_group.add(a_missile) a_missile.play_sound(True) # --------------------- Key Handlers ----------------------# def keydown(key): if key == simplegui.KEY_MAP['left']: my_ship.set_angle_vel(-SHIP_ANG_VEL) elif key == simplegui.KEY_MAP['right']: my_ship.set_angle_vel(SHIP_ANG_VEL) elif key == simplegui.KEY_MAP['up']: my_ship.set_thrust(True) elif key == simplegui.KEY_MAP['space']: my_ship.shoot() def keyup(key): if key == simplegui.KEY_MAP['left']: my_ship.set_angle_vel(0) elif key == simplegui.KEY_MAP['right']: my_ship.set_angle_vel(0) elif key == simplegui.KEY_MAP['up']: my_ship.set_thrust(False) # -------------------- Mouse Handler ----------------------# def click(pos): global started, lives, score 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: score = 0 lives = MAX_LIVES started = True soundtrack.rewind() soundtrack.play() # ------------ Sprite Group Handlers ----------------------# # helper function to process sprite group def process_sprite_group(canvas, group): # create a temp set to iterate on tmp_group = set(group) # start with empty age group age_group = set([]) # draw and update all sprites in a group for sprite in group: sprite.draw(canvas) sprite.update() if sprite.is_aged(): age_group.add(sprite) # remvoe aged sprites from the group group.difference_update(age_group) # helper function to check if a_spite collide with a group of sprites # return the set of sprites that collide, empty set if none def group_collide(group, a_sprite): # create a temp set to iterate on tmp_group = set(group) # start with empty collision set col_group = set([]) for sprite in tmp_group: if sprite.collide(a_sprite): col_group.add(sprite) return col_group # helper function to check if a sprite group collide with another sprite group # return the set of sprites that collide, empty set if none # return value contain a list of two sets, one for the first group # and the second for the other group def group_group_collide(group1, group2): # create a temp set to iterate on tmp_group = set(group1) # start with empty collision sets col_group1 = set([]) col_group2 = set([]) for sprite in tmp_group: # find all elements of group2 that collide with sprite col_group = group_collide(group2, sprite) # add them to the collide elements of group2 col_group2.update(col_group) # if collision found, add sprite to the collision group1 if len(col_group)>0: col_group1.add(sprite) return [col_group1,col_group2] # helper function to spawn explosion sprites from asteroid group # input: asteroid group to be explode def spawn_explosions(group): global explosion_group tmp_group = set(group) for sprite in tmp_group: e_sprite = Sprite(sprite.get_pos(), sprite.get_vel(), 0, 0, explosion_image, explosion_info, explosion_sound) explosion_group.add(e_sprite) e_sprite.play_sound(True) e_sprite.animate(EXPLOSION_RATE) # -------------------- Draw Handler -----------------------# def draw(canvas): global time, lives, score, started # animiate background time += 1 wtime = (time / 4) % WIDTH center = debris_info.get_center() size = debris_info.get_size() 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, size, (wtime - WIDTH / 2, HEIGHT / 2), (WIDTH, HEIGHT)) canvas.draw_image(debris_image, center, size, (wtime + WIDTH / 2, HEIGHT / 2), (WIDTH, HEIGHT)) if not started: # draw splash screen if not started canvas.draw_image(splash_image, splash_info.get_center(), splash_info.get_size(), [WIDTH / 2, HEIGHT / 2], splash_info.get_size()) else: # started # draw ship and sprites my_ship.draw(canvas) my_ship.update() process_sprite_group(canvas, rock_group) process_sprite_group(canvas, missile_group) # check collision between rock and ship, # update lives and remove rock in case of collision col_group = group_collide(rock_group, my_ship) lives -= len(col_group) rock_group.difference_update(col_group) if lives == 0: restart_game() spawn_explosions(col_group) # check collision between rock and missile groups # remove collide missiles # remove collide rocks and add number of hits to the score col_groups = group_group_collide(rock_group, missile_group) score += len(col_groups[0]) rock_group.difference_update(col_groups[0]) spawn_explosions(col_groups[0]) missile_group.difference_update(col_groups[1]) process_sprite_group(canvas, explosion_group) # draw the live and score canvas.draw_text("Lives", [50, 50], 22, "White") canvas.draw_text("Score", [680, 50], 22, "White") canvas.draw_text(str(lives), [50, 80], 22, "White") canvas.draw_text(str(score), [680, 80], 22, "White") # ----------------- Rock Timer Handler --------------------# def rock_spawner(): global rock_group, started, my_ship if not started: return # set a random pos and velocity dirs = [-1,1] # find rock position that's far enough from the ship while True: # pos is set to the entire screen within a margin pos = [random.randrange(ROCK_SP_MARGIN, WIDTH-ROCK_SP_MARGIN), random.randrange(ROCK_SP_MARGIN, HEIGHT-ROCK_SP_MARGIN)] if (dist(pos, my_ship.get_pos()) >= ROCK_SHIP_MARGIN + asteroid_info.get_radius() + my_ship.get_radius()): break # velocity is set to a random range, multiplied by a random dir vel = [random.choice(dirs)*float(random.randrange(ROCK_MIN_VEL, ROCK_MAX_VEL)/FRAME_RATE), random.choice(dirs)*float(random.randrange(ROCK_MIN_VEL, ROCK_MAX_VEL)/FRAME_RATE)] # increase velocity based on score vel[0] *=(1+SCORE_VEL_MUL*score) vel[1] *=(1+SCORE_VEL_MUL*score) ang_vel = random.choice(dirs)*float(random.randrange(ROCK_MIN_ANG_VEL, ROCK_MAX_ANG_VEL)/FRAME_RATE) if len(rock_group) < MAX_ROCKS: rock_group.add(Sprite(pos, vel, 0, ang_vel, asteroid_image, asteroid_info)) # ----------- Load all graphic and sound assets ----------# """ 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.s2014.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, None, True, [2,1]) 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, [24,1]) 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") # ------------------- Initialization ---------------------# frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT) # initialize ship and two sprites def restart_game(): global time, started, rock_group, missile_group, my_ship, soundtrack, explosion_group my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info, ship_thrust_sound) rock_group = set([]) missile_group = set([]) explosion_group = set([]) time = 0.5 started = False soundtrack.pause() def init_game(): global score, lives score = 0 lives = MAX_LIVES restart_game() # ---------------- Register Handlers ---------------------# frame.set_draw_handler(draw) frame.set_keydown_handler(keydown) frame.set_keyup_handler(keyup) frame.set_mouseclick_handler(click) # ------------------- Start Rolling ----------------------# init_game() timer = simplegui.create_timer(1000.0, rock_spawner) timer.start() frame.start()

This page contains Python games written as part of the Coursera "An Introduction to Interactive Programming in Python" Course by Rice University. The Python code is converted into javaScript using codeskulptor.org environment so it runs as a web interactive window. Running the games require new browser support - it doesn't work with old browser versions.
Games	Output
Guess The Number Game In this game the player try to guess the number the computer chosen. There are option to guess a number between 0-100 in 7 guesses or a number between 0-1000 in 10 guesses. After running the game, write your guess in the text area and click Enter. In the output you see how the status Run Game
Stop Watch Game In this game a stop watch is shown. The player tries to run and stop the watch on a round sec. A count of the number of success vs. number of tries is shown Run Game
Memory Card Game This is a memory card game. The player clicks on a card and try to find pair of cards If the cards are a pair, they are kept exposed. If not they are flipped over My record for exposing all cards is 11 turns Run Game
Pong Game In this game the player need to move the paddles and keep the ball in the game To move the Right paddle up/down arrows are used To move the left paddle w/s keys are used Every successful hit the ball moves faster to make the game more interesting Run Game
BlackJack Game In this game the player plays against a dealer with the goal of having cards with a total value higher than the dealer's hand, but not over 21. The player and the dealer are each start with two cards and one of the dealer's cards faced down. The player can "hit" to deal a new card. If the total value of the cards is over 21, the player loses. At any point before reaching 21, the player may "stand" and the dealer will then hit his hand he stand. If the dealer cards are over 21, the player wins. If no one cards are over 21, the one with the highest value win. Tie is in favor of the dealer. An ace may be valued as either 1 or 11 and face cards (kings, queens and jacks) are valued at 10. Run Game
Asteroid Game Try to shot asteroids. Left/Right key to turn, Up key to thrust, space to shoot Run Game comments powered by Disqus