From 5edb8414a4e0530ceee4082b81fff02d2a91eae2 Mon Sep 17 00:00:00 2001 From: Winlandiano Date: Wed, 29 Oct 2014 01:42:29 +0800 Subject: [PATCH] Fix some error in BlackJack.py --- .gitignore | 35 ++++++ BlackJack.py | 289 ++++++++++++++++++++++++++++++++++++++++++++ Guess_the_number.py | 88 ++++++++++++++ Memory.py | 126 +++++++++++++++++++ PingPong.py | 144 ++++++++++++++++++++++ README.md | 4 + RPSLS.py | 83 +++++++++++++ Spaceship.py | 261 +++++++++++++++++++++++++++++++++++++++ Stopwatch.py | 79 ++++++++++++ 9 files changed, 1109 insertions(+) create mode 100755 .gitignore create mode 100755 BlackJack.py create mode 100755 Guess_the_number.py create mode 100755 Memory.py create mode 100755 PingPong.py create mode 100755 README.md create mode 100755 RPSLS.py create mode 100755 Spaceship.py create mode 100755 Stopwatch.py diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..d2d6f36 --- /dev/null +++ b/.gitignore @@ -0,0 +1,35 @@ +*.py[cod] + +# C extensions +*.so + +# Packages +*.egg +*.egg-info +dist +build +eggs +parts +bin +var +sdist +develop-eggs +.installed.cfg +lib +lib64 + +# Installer logs +pip-log.txt + +# Unit test / coverage reports +.coverage +.tox +nosetests.xml + +# Translations +*.mo + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject diff --git a/BlackJack.py b/BlackJack.py new file mode 100755 index 0000000..eeacaaf --- /dev/null +++ b/BlackJack.py @@ -0,0 +1,289 @@ +# 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 +flag = False +# flag stands for game over, +win = 0 +loss = 0 +wind = 0 +lossd = 0 +count = 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.hand = [] + self.rank1 = [] + self.suit1 = [] + self.position = [] + self.hundred = 0 + self.count = -1 + + def __str__(self): + s = "" + i = 0 + while i in range(0, len(self.hand)): + s += (str(self.hand[i]) + " ") + i += 1 + return s + + def add_card(self, card): + self.hundred += 100 + self.position.append(self.hundred) + self.rank1.append(card.get_rank()) + self.suit1.append(card.get_suit()) + self.hand.append(card.get_suit() + card.get_rank()) + + # count aces as 1, if the hand has an ace, then add 10 to hand value if it doesn't bust + def get_value(self): + self.value = 0 + ace_num=0 + for i in range(0, len(self.rank1)): + if (self.rank1[i] == 'A' and self.value <= 10): + ace_num += 1 + self.value+=1 + else: + self.value += VALUES.get(self.rank1[i]) + for i in xrange(0,ace_num): + if self.value<=11: + self.value+=10 + return self.value + + def draw(self, canvas, p, r, s): + card_location = (CARD_CENTER[0] + CARD_SIZE[0] * RANKS.index(r), + CARD_CENTER[1] + CARD_SIZE[1] * SUITS.index(s)) + canvas.draw_image(card_images, card_location, CARD_SIZE, [p[0] + CARD_CENTER[0], p[1] + CARD_CENTER[1]], CARD_SIZE) + + def drawback(self, canvas, p): + card_location1 = (CARD_BACK_CENTER[0], CARD_BACK_CENTER[1]) + canvas.draw_image(card_back, card_location1, CARD_BACK_SIZE, [p[0] + CARD_BACK_CENTER[0], p[1] + CARD_BACK_CENTER[1]], CARD_BACK_SIZE) + +# define deck class +class Deck: + def __init__(self): + self.choice = -1 + del self.deck + self.deck = [] + for i in range(1, 14): + j = str(i) + if (j == '1'): + self.deck.append(Card('C', 'A').get_suit() + " " + Card('C', 'A').get_rank()) + self.deck.append(Card('S', 'A').get_suit() + " " + Card('C', 'A').get_rank()) + self.deck.append(Card('H', 'A').get_suit() + " " + Card('C', 'A').get_rank()) + self.deck.append(Card('D', 'A').get_suit() + " " + Card('C', 'A').get_rank()) + elif (j == '10'): + self.deck.append(Card('C', 'T').get_suit() + " " + Card('C', 'T').get_rank()) + self.deck.append(Card('S', 'T').get_suit() + " " + Card('C', 'T').get_rank()) + self.deck.append(Card('H', 'T').get_suit() + " " + Card('C', 'T').get_rank()) + self.deck.append(Card('D', 'T').get_suit() + " " + Card('C', 'T').get_rank()) + elif (j == '11'): + self.deck.append(Card('C', 'J').get_suit() + " " + Card('C', 'J').get_rank()) + self.deck.append(Card('S', 'J').get_suit() + " " + Card('C', 'J').get_rank()) + self.deck.append(Card('H', 'J').get_suit() + " " + Card('C', 'J').get_rank()) + self.deck.append(Card('D', 'J').get_suit() + " " + Card('C', 'J').get_rank()) + elif (j == '12'): + self.deck.append(Card('C', 'Q').get_suit() + " " + Card('C', 'Q').get_rank()) + self.deck.append(Card('S', 'Q').get_suit() + " " + Card('C', 'Q').get_rank()) + self.deck.append(Card('H', 'Q').get_suit() + " " + Card('C', 'Q').get_rank()) + self.deck.append(Card('D', 'Q').get_suit() + " " + Card('C', 'Q').get_rank()) + elif (j == '13'): + self.deck.append(Card('C', 'K').get_suit() + " " + Card('C', 'K').get_rank()) + self.deck.append(Card('S', 'K').get_suit() + " " + Card('C', 'K').get_rank()) + self.deck.append(Card('H', 'K').get_suit() + " " + Card('C', 'K').get_rank()) + self.deck.append(Card('D', 'K').get_suit() + " " + Card('C', 'K').get_rank()) + else: + self.deck.append(Card('C', j).get_suit() + " " + Card('C', j).get_rank()) + self.deck.append(Card('S', j).get_suit() + " " + Card('C', j).get_rank()) + self.deck.append(Card('H', j).get_suit() + " " + Card('C', j).get_rank()) + self.deck.append(Card('D', j).get_suit() + " " + Card('C', j).get_rank()) + # add cards back to deck and shuffle + def shuffle(self): + random.shuffle(self.deck) + + def deal_card(self): + self.choice += 1 + return self.deck[self.choice] + + def __str__(self): + return str(self.deck) + +#define event handlers for buttons +def deal(): + global flag, deck, player, dealer, count, loss, wind, count + count = 2 + flag = False + player = Hand() + dealer = Hand() + deck = Deck() + deck.shuffle() + for i in range(0, 2): + deal1 = deck.deal_card() + split1 = deal1.split() + card1 = Card(split1[0], split1[1]) + player.add_card(card1) + deal2 = deck.deal_card() + split2 = deal2.split() + card2 = Card(split2[0], split2[1]) + dealer.add_card(card2) + +def hit(): + global flag, loss, deck, player, dealer, wind, count + if (count < 5 and flag==False): + if (player.get_value() <= 21): + print(count) + count += 1 + hit = deck.deal_card() + split = hit.split() + card = Card(split[0], split[1]) + player.add_card(card) + if (player.get_value() > 21): + count = 6 + flag=True + if player.get_value()>21: + loss+=1 + wind+=1 + elif dealer.get_value()>21: + win+=1 + lossd+=1 + elif dealer.get_value()>=player.get_value(): + loss+=1 + wind+=1 + else: + win+=1 + lossd+=1 + +def stand(): + global flag, win, loss, wind, lossd + if (flag == False and player.get_value() <= 21): + countd = 0 + while ((dealer.get_value() < 17) and (countd<5)): + hit = deck.deal_card() + split = hit.split() + card = Card(split[0], split[1]) + dealer.add_card(card) + countd+=1 + flag = True + if player.get_value()>21: + loss+=1 + wind+=1 + elif dealer.get_value()>21: + win+=1 + lossd+=1 + elif dealer.get_value()>=player.get_value(): + loss+=1 + wind+=1 + else: + win+=1 + lossd+=1 + +# draw handler +def draw(canvas): + global flag, deck, player, dealer + # test to make sure that card.draw works, replace with your code below + canvas.draw_text("Player's Hand:" + str(player.get_value()), (10, 350), 12, "Yellow") + canvas.draw_text("Player", (40, 150), 12, "White") + canvas.draw_text("Dealer", (40, 250), 12, "White") + canvas.draw_text("Player Wins:" + str(win), (455, 350), 12, "White") + canvas.draw_text("Player Losses:" + str(loss), (455, 380), 12, "White") + canvas.draw_text("Dealer Wins:" + str(wind), (300, 350), 12, "White") + canvas.draw_text("Dealer Losses:" + str(lossd), (300, 380), 12, "White") + canvas.draw_text("BlackJack", (180, 40), 30, "Red") + if (flag == False and player.get_value() <= 21): + canvas.draw_text("Hit or Stand?", (180, 550), 20, "Black") + for i in range(0, len(player.position)): + player.draw(canvas, [player.position[i], player.position[0]], player.rank1[i], player.suit1[i]) + if (flag == True): + dealer.draw(canvas, [dealer.position[0], dealer.position[1]], dealer.rank1[0], dealer.suit1[0]) + else: + dealer.drawback(canvas, [dealer.position[0], dealer.position[1]]) + for j in range(1, len(dealer.position)): + dealer.draw(canvas, [dealer.position[j], dealer.position[1]], dealer.rank1[j], dealer.suit1[j]) + + if ((player.get_value() > 21) and (flag == True)): + canvas.draw_text("Player is Busted", (180, 480), 20, "Black") + canvas.draw_text("New Deal?", (180, 550), 20, "Black") + elif ((player.get_value() == dealer.get_value()) and (dealer.get_value() >= 17) and (flag == True)): + canvas.draw_text("Tie!! Dealer Wins", (180, 480), 20, "Black") + canvas.draw_text("Dealer's Hand:" + str(dealer.get_value()), (10, 380), 12, "Yellow") + canvas.draw_text("New Deal?", (180, 550), 20, "Black") + elif (dealer.get_value()>21) and (flag==True): + canvas.draw_text("Dealer is Busted!! Player Wins", (180, 480), 20, "Black") + canvas.draw_text("Dealer's Hand:" + str(dealer.get_value()), (10, 380), 12, "Yellow") + canvas.draw_text("New Deal?", (180, 550), 20, "Black") + elif ((dealer.get_value() > player.get_value()) and (dealer.get_value() >= 17) and (flag == True)): + canvas.draw_text("Dealer Wins", (180, 480), 20, "Black") + canvas.draw_text("Dealer's Hand:" + str(dealer.get_value()), (10, 380), 12, "Yellow") + canvas.draw_text("New Deal?", (180, 550), 20, "Black") + elif ((player.get_value() > dealer.get_value()) and (dealer.get_value() >= 17) and (flag == True)): + canvas.draw_text("Player Wins", (180, 480), 20, "Black") + canvas.draw_text("Dealer's Hand:" + str(dealer.get_value()), (10, 380), 12, "Yellow") + canvas.draw_text("New Deal?", (180, 550), 20, "Black") + +# deal an initial hand +player = Hand() +dealer = Hand() +deck = Deck() +deck.shuffle() +for i in range(0, 2): + deal1 = deck.deal_card() + split1 = deal1.split() + card1 = Card(split1[0], split1[1]) + player.add_card(card1) + deal2 = deck.deal_card() + split2 = deal2.split() + card2 = Card(split2[0], split2[1]) + dealer.add_card(card2) + +# 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 +frame.start() \ No newline at end of file diff --git a/Guess_the_number.py b/Guess_the_number.py new file mode 100755 index 0000000..6f6da29 --- /dev/null +++ b/Guess_the_number.py @@ -0,0 +1,88 @@ + +import random +import simplegui +import math + +# initialize global variables used in your code +global secret, count, count100, count1000 + +#number of guesses restriction +count100 = math.log((100 - 0 + 1),2) +count100 = math.ceil(count100) +count1000 = math.log((1000 - 0 + 1),2) +count1000 = math.ceil(count1000) + +# define event handlers for control panel +def range100(): + global secret, count, count100 + count = count100 + print "New game. Range is from 0 to 100" + print "Number of guesses remaining: ",count + print "" + secret = random.randrange(0,100) + +def range1000(): + global secret, count, count1000 + count = count1000 + print "New game. Range is from 0 to 1000" + print "Number of guesses remaining: ",count + print "" + secret = random.randrange(0,1000) + +#decrement count after each guess +def decrement(): + global count + count = count - 1 + print "Number of guesses remaining: ",count + print "" + + +def get_input(guess): + global secret, count, count100, count1000 + + guess = int(guess) + print "Guess was",guess + if(secret < guess): + print "Secret number is lower" + decrement() + elif(secret > guess): + print "Secret number is higher" + decrement() + else: + print "Correct guess. You Win!!" + print "" + print "Starting new game" + range100() + + if (count < 1): + print "You ran out of guesses. You lose!!" + print "Number was",secret + print "" + range100() + +#exit event handler +def stop_game(): + frame.stop() + +#reveal the answer mid-way +def reveal(): + print "Number was", secret + print "Starting new game" + print "" + range100() + +#start with range from 0 - 100 +range100() + +# create frame +frame = simplegui.create_frame("Guess the number",300,300) + +# register event handlers for control elements +frame.add_button("Range [0,100)", range100, 200) +frame.add_button("Range [0,1000)", range1000, 200) +frame.add_input("Enter your guess", get_input, 100) +frame.add_button("Reveal secret number", reveal, 200) +frame.add_button("Exit game", stop_game, 200) + +# start frame +frame.start() diff --git a/Memory.py b/Memory.py new file mode 100755 index 0000000..ece3b0f --- /dev/null +++ b/Memory.py @@ -0,0 +1,126 @@ +# Implementation of card game - Memory +import simplegui +import random +global counter, m, index1, index2, choice1, choice2, state, val, position, exposed, numbers, CARD_WIDTH, CARD_LENGTH, HALF_CARD_WIDTH, HALF_CARD_LENGTH +numbers = [] +exposed = [] +position = [0] +val = range(16) +state = 0 +choice1 = [] +choice2 = [] +index1 = [] +index2 = [] +m = 1 +counter = 0 +win = 0 + +def dimensions(): + global CARD_WIDTH, CARD_LENGTH, HALF_CARD_WIDTH, HALF_CARD_LENGTH + CARD_WIDTH = 50 + HALF_CARD_WIDTH = CARD_WIDTH // 2 + CARD_LENGTH = 100 + HALF_CARD_LENGTH = CARD_LENGTH // 2 + + +# helper function to initialize globals +def init(): + global val, choice1, choice2, index1, index2, m, counter, state, numbers, exposed, CARD_WIDTH, CARD_LENGTH, HALF_CARD_WIDTH, HALF_CARD_LENGTH + dimensions() + numbers = [] + exposed = [] + state = 0 + choice1 = [] + choice2 = [] + index1 = [] + index2 = [] + m = 1 + counter = 0 + l.set_text("Moves = 0") + val = range(16) + for i in range(16): + if (i < 8): + numbers.append(i) + exposed.append(False) + position.append(HALF_CARD_WIDTH + ((CARD_WIDTH//2)+1)) + HALF_CARD_WIDTH += CARD_WIDTH + 1 + else: + numbers.append(i - 8) + exposed.append(False) + position.append(HALF_CARD_WIDTH + ((CARD_WIDTH//2)+1)) + HALF_CARD_WIDTH += CARD_WIDTH + 1 + random.shuffle(numbers) + +# define event handlers +def mouseclick(pos): + global counter, m, index1, index2, choice1, choice2, state, val, exposed + if state == 0: + for i in range(16): + if (pos[0] > position[i]) and (pos[0] < position[i + 1]): + val[i] = numbers[i] + if exposed[i] == True: + state = 0 + elif exposed[i] == False: + compare() + choice1.append(val[i]) + index1.append(i) + exposed[i] = True + state = 1 + + elif state == 1: + for i in range(16): + if (pos[0] > position[i]) and (pos[0] < position[i + 1]): + val[i] = numbers[i] + if exposed[i] == True: + state = 1 + elif exposed[i] == False: + choice2.append(val[i]) + index2.append(i) + exposed[i] = True + state = 0 + m += 1 + counter += 1 + l.set_text("Moves = " + str(counter)) + +def compare(): + global win, index1, index2, choice1, choice2 + if m > 1: + for i in range(len(choice1)): + if (choice1[i] == choice2[i]): + exposed[index1[i]] = True + exposed[index2[i]] = True + else: + exposed[index1[i]] = False + exposed[index2[i]] = False + +# cards are logically 50x100 pixels in size +def draw(canvas): + global val, exposed, position, numbers, CARD_WIDTH, HALF_CARD_WIDTH, HALF_CARD_LENGTH + for i in range(16): + if (exposed[i] == True): + display = str(val[i]) + canvas.draw_text(display, [position[i] + HALF_CARD_WIDTH/1.5, HALF_CARD_LENGTH], 15, "White") + else: + canvas.draw_line(((position[i] + HALF_CARD_WIDTH),0), ((position[i] + HALF_CARD_WIDTH),CARD_LENGTH), CARD_WIDTH, "White") + win = 0 + for i in range(16): + if (exposed[i] == True): + win += 1 + if (win == 16): + l.set_text("You Won!!!!!") + dimensions() + +# create frame and add a button and labels +frame = simplegui.create_frame("Memory", 815, 100) +frame.add_button("Restart", init) +l=frame.add_label("Moves = 0") + +# initialize global variables +init() + +# register event handlers +frame.set_mouseclick_handler(mouseclick) +frame.set_draw_handler(draw) + +# get things rolling +frame.start() diff --git a/PingPong.py b/PingPong.py new file mode 100755 index 0000000..9cd027f --- /dev/null +++ b/PingPong.py @@ -0,0 +1,144 @@ +# Implementation of classic arcade game Pong +import simplegui +import random + +# initialize globals - pos and vel encode vertical info for paddles +global ball_pos, ball_vel +WIDTH = 600 +HEIGHT = 400 +BALL_RADIUS = 10 +PAD_WIDTH = 8 +PAD_HEIGHT = 80 +HALF_PAD_WIDTH = PAD_WIDTH / 2 +HALF_PAD_HEIGHT = PAD_HEIGHT / 2 +iterate = 0 +score1 = "0" +score2 = "0" + +# helper function that spawns a ball, returns a position vector and a velocity vector +def ball_init(): + global acc1, ball_pos, ball_vel, iterate + ball_pos = [WIDTH/2, HEIGHT/2] + if (iterate == 2): + ball_vel = [random.randrange(1,5), random.randrange(1,5)] + else: + ball_vel = [-(random.randrange(1,5)), -(random.randrange(1,5))] + acc1 = 1 + +# define event handlers +def init(): + global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel, ball_pos # these are floats + global score1, score2 # these are ints + paddle1_pos = [0, HEIGHT/2] + paddle2_pos = [WIDTH, HEIGHT/2] + paddle1_vel = 0 + paddle2_vel = 0 + ball_pos = [WIDTH/2, HEIGHT/2] + score1 = int(score1) + score1 = 0 + score1 = str(score1) + score2 = int(score2) + score2 = 0 + score2 = str(score2) + +def draw(c): + global acc1, score1, score2, paddle1_pos, paddle2_pos, ball_pos, ball_vel, iterate, paddle2_vel, paddle1_vel + + # update paddle's vertical position, keep paddle on the screen + if (paddle2_pos[1] >= PAD_HEIGHT/80 and paddle2_pos[1] <= (HEIGHT - PAD_HEIGHT)): + paddle2_pos[1] = paddle2_pos[1] - paddle2_vel + elif (paddle2_pos[1] < PAD_HEIGHT/80): + paddle2_pos[1] = paddle2_pos[1] + 1 + elif (paddle2_pos[1] > (HEIGHT - PAD_HEIGHT)): + paddle2_pos[1] = paddle2_pos[1] - 1 + + if (paddle1_pos[1] >= PAD_HEIGHT/80 and paddle1_pos[1] <= (HEIGHT - PAD_HEIGHT)): + paddle1_pos[1] = paddle1_pos[1] - paddle1_vel + elif (paddle1_pos[1] < PAD_HEIGHT/80): + paddle1_pos[1] = paddle1_pos[1] + 1 + elif (paddle1_pos[1] > (HEIGHT - PAD_HEIGHT)): + paddle1_pos[1] = paddle1_pos[1] - 1 + + # draw mid line and gutters + c.draw_line([WIDTH / 2, 0],[WIDTH / 2, HEIGHT], 1, "White") + c.draw_line([PAD_WIDTH, 0],[PAD_WIDTH, HEIGHT], 1, "White") + c.draw_line([WIDTH - PAD_WIDTH, 0],[WIDTH - PAD_WIDTH, HEIGHT], 1, "White") + + # draw paddles + c.draw_line(paddle1_pos, ((paddle1_pos[0] + PAD_WIDTH), paddle1_pos[1]), 1, "White") + c.draw_line(((paddle1_pos[0] + PAD_WIDTH/2), paddle1_pos[1]), ((paddle1_pos[0] + PAD_WIDTH/2), (paddle1_pos[1] + PAD_HEIGHT)), PAD_WIDTH, "White") + c.draw_line(((paddle1_pos[0] + PAD_WIDTH), (paddle1_pos[1] + PAD_HEIGHT)), ((paddle1_pos[0] - PAD_WIDTH), (paddle1_pos[1] + PAD_HEIGHT)), 1, "White") + c.draw_line(paddle2_pos, ((paddle2_pos[0] - PAD_WIDTH), paddle2_pos[1]), 1, "White") + c.draw_line(((paddle2_pos[0] - PAD_WIDTH/2), paddle2_pos[1]), ((paddle2_pos[0] - PAD_WIDTH/2), (paddle2_pos[1] + PAD_HEIGHT)), PAD_WIDTH, "White") + c.draw_line(((paddle2_pos[0] - PAD_WIDTH), (paddle2_pos[1] + PAD_HEIGHT)), (paddle2_pos[0], (paddle2_pos[1] + PAD_HEIGHT)), 1, "White") + c.draw_line((paddle2_pos[0], (paddle2_pos[1] + PAD_HEIGHT)), paddle2_pos, 1, "White") + + # update ball + ball_pos[0] = ball_pos[0] + ball_vel[0] + ball_pos[1] = ball_pos[1] + ball_vel[1] + + if ((ball_pos[0] + (2 * BALL_RADIUS)) >= WIDTH): + score1 = int(score1) + score1 += 1 + score1 = str(score1) + iterate = 1 + ball_init() + elif ((ball_pos[0] - (2 * BALL_RADIUS)) <= 0): + score2 = int(score2) + score2 += 1 + score2 = str(score2) + iterate = 2 + ball_init() + elif ((ball_pos[1] >= (paddle2_pos[1] - 5)) and (ball_pos[1] <= (paddle2_pos[1] + PAD_HEIGHT + 5)) and ((ball_pos[0] + (2 * BALL_RADIUS)) >= (WIDTH - PAD_WIDTH - 2))): + ball_vel[0] += acc1 + ball_vel[0] = -(ball_vel[0]) + elif ((ball_pos[1] >= (paddle1_pos[1] - 5)) and (ball_pos[1] <= (paddle1_pos[1] + PAD_HEIGHT + 5)) and ((ball_pos[0] - (2 * BALL_RADIUS)) <= (PAD_WIDTH + 2))): + ball_vel[0] -= acc1 + ball_vel[0] = -(ball_vel[0]) + + + if ((ball_pos[1] + (2 * BALL_RADIUS)) >= HEIGHT): + ball_vel[1] = -(ball_vel[1]) + elif ((ball_pos[1] - (2 * BALL_RADIUS)) <= 0): + ball_vel[1] = -(ball_vel[1]) + + # draw ball and scores + c.draw_circle(ball_pos, BALL_RADIUS, 20,"Green") + c.draw_text(score1,(250, 50), 24, "Red") + c.draw_text(score2,(337, 50), 24, "Blue") + +def keydown(key): + acc = 10 + global paddle1_vel, paddle2_vel + if (key == simplegui.KEY_MAP["up"]): + paddle2_vel += acc + elif key == simplegui.KEY_MAP["down"]: + paddle2_vel -= acc + if key == simplegui.KEY_MAP["w"]: + paddle1_vel += acc + elif key == simplegui.KEY_MAP["s"]: + paddle1_vel -= acc + +def keyup(key): + acc = 10 + global paddle1_vel, paddle2_vel + if key == simplegui.KEY_MAP["up"]: + paddle2_vel -= acc + elif key == simplegui.KEY_MAP["down"]: + paddle2_vel += acc + if key == simplegui.KEY_MAP["w"]: + paddle1_vel -= acc + elif key == simplegui.KEY_MAP["s"]: + paddle1_vel += acc + +# 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", init, 100) + +# start frame +init() +ball_init() +frame.start() diff --git a/README.md b/README.md new file mode 100755 index 0000000..50be8a2 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +Python_Games +============ + +"An Introduction to Interactive Programming in Python" Coursera Assignments. \ No newline at end of file diff --git a/RPSLS.py b/RPSLS.py new file mode 100755 index 0000000..49d9ddf --- /dev/null +++ b/RPSLS.py @@ -0,0 +1,83 @@ +# Rock-Paper-Scissors-Lizard-Spock +# 0 - rock +# 1 - Spock +# 2 - paper +# 3 - lizard +# 4 - scissors + +import random + +# helper functions + +#assign name to given number +def number_to_name(number): + if (number == 0): + name = "rock" + elif (number == 1): + name = "spock" + elif (number == 2): + name = "paper" + elif (number == 3): + name = "lizard" + elif (number == 4): + name = "scissors" + else: + name = "null" + return name + +#assign number to given name +def name_to_number(name): + if (name == "rock"): + num = 0 + elif (name == "spock"): + num = 1 + elif (name == "paper"): + num = 2 + elif (name == "lizard"): + num = 3 + elif (name == "scissors"): + num = 4 + else: + num = 5 + return num + +#decide winner +def rpsls(guess): + + player_number = name_to_number(guess) + + #Print player's choice + + print "Player chooses",guess + + #Select random computer's choice + + comp_number = random.randrange(0,5) + + #Convert computer's choice to name + + comp_name = number_to_name(comp_number) + + #Print computer's choice + + print "Computer chooses",comp_name + + subtract = player_number - comp_number + + rem = subtract % 5 + + if (rem == 1 or rem == 2): + print "Player wins!\n" + elif (rem == 3 or rem == 4): + print "Computer wins!\n" + else: + print "Player and computer tie!\n" + + return 0 + + +rpsls("rock") +rpsls("Spock") +rpsls("paper") +rpsls("lizard") +rpsls("scissors") diff --git a/Spaceship.py b/Spaceship.py new file mode 100755 index 0000000..363e65a --- /dev/null +++ b/Spaceship.py @@ -0,0 +1,261 @@ +#KINDLY RELOAD THE CODE 3-4 TIMES IF THINGS DO NOT LOAD UP IN FIRST GO +#..................................................................... +#APOLOGY FOR THE INCONVENIENCE........................................ +#..................................................................... +# program template for Spaceship +import simplegui +import math +import random + +# globals for user interface +width = 800 +height = 600 +score = 0 +lives = 3 +time = 0 + +def incr(): + my_ship.increment() + +def decr(): + my_ship.decrement() + +def acc(): + ship_thrust_sound.play() + ship_thrust_sound.set_volume(1) + my_ship.thrust = True + my_ship.thrusters() + +def bullet(): + missile_sound.play() + missile_sound.set_volume(1) + a_missile.pos[0] = my_ship.pos[0] + (my_ship.image_size[0]/2)*angle_to_vector(my_ship.angle)[0] + a_missile.pos[1] = my_ship.pos[1] + (my_ship.image_size[1]/2)*angle_to_vector(my_ship.angle)[1] + a_missile.vel[0] = 15*(angle_to_vector(my_ship.angle)[0]) + a_missile.vel[1] = 15*(angle_to_vector(my_ship.angle)[1]) + +def misc(): + my_ship.thrust = False + my_ship.decel = True + +press = {"right": incr, "left": decr, "up": acc, "space": bullet} +release = {"right": decr, "left": incr, "up": misc} + +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, angle, image, info): + self.pos = [pos[0],pos[1]] + self.thrust = False + self.decel = False + self.angle = angle + 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.boost = 1 + self.orient = angle + + def draw(self,canvas): + #canvas.draw_circle(self.pos, self.radius, 1, "White", "White") + if (self.thrust == False): + canvas.draw_image(self.image, self.image_center, self.image_size, self.pos, self.image_size, self.angle) + elif (self.thrust == True): + canvas.draw_image(self.image, [130, 45], self.image_size, self.pos, self.image_size, self.angle) + + def update(self): + self.angle += self.angle_vel + if (self.pos[1] < -20): + self.pos[1] = height + elif (self.pos[1] > 620): + self.pos[1] = 0 + elif (self.pos[0] < -20): + self.pos[0] = width + elif (self.pos[0] > 820): + self.pos[0] = 0 + else: + #Cruise + if (self.thrust == False and self.decel == False): + self.pos[0] += self.boost*(angle_to_vector(self.orient)[0]) + self.pos[1] += self.boost*(angle_to_vector(self.orient)[1]) + #Accelerate + if (self.thrust == True): + self.orient = self.angle + self.pos[0] += self.boost*(angle_to_vector(self.angle)[0]) + self.pos[1] += self.boost*(angle_to_vector(self.angle)[1]) + #Decelerate + elif (self.thrust == False and self.decel == True): + self.boost -= 0.05 + self.pos[0] += self.boost*(angle_to_vector(self.orient)[0]) + self.pos[1] += self.boost*(angle_to_vector(self.orient)[1]) + if (self.boost < 1): + self.boost = 1 + self.decel = False + + def increment(self): + self.angle_vel += 0.1 + + def decrement(self): + self.angle_vel -= 0.1 + + def thrusters(self): + self.boost = 7 + +# 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) + + def update(self): + self.pos[0] += self.vel[0] + self.pos[1] += self.vel[1] + self.angle += self.angle_vel + +def draw(canvas): + global time, lives, score + + # 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]) + canvas.draw_image(debris_image, [size[0]-wtime, center[1]], [2*wtime, size[1]], + [1.25*wtime, height/2], [2.5*wtime, height]) + + # draw ship and sprites + my_ship.draw(canvas) + a_rock.draw(canvas) + a_missile.draw(canvas) + + # update ship and sprites + my_ship.update() + a_rock.update() + a_missile.update() + + canvas.draw_text('LIVES LEFT : ' + str(lives), (20, 30), 10, "White") + canvas.draw_text('SCORE : ' + str(score), (680, 30), 10, "White") + +def keyd(key): + for i in press: + if (key == simplegui.KEY_MAP[i]): + press[i]() + +def keyu(key): + for i in release: + if (key == simplegui.KEY_MAP[i]): + release[i]() + +# timer handler that spawns a rock +def rock_spawner(): + a_rock.vel[0] = random.randrange(-5, 5) + a_rock.vel[1] = random.randrange(-5, 5) + a_rock.angle_vel = random.randrange(1, 5) + a_rock.pos[0] = random.randrange(0, 800) + a_rock.pos[1] = random.randrange(0, 600) + +# initialize frame +frame = simplegui.create_frame("Asteroids", width, height) + +# initialize ship and two sprites +my_ship = Ship([width / 2, height / 2], 0, ship_image, ship_info) +a_rock = Sprite([width / 3, height / 3], [random.random(), random.random()], 0, random.random(), asteroid_image, asteroid_info) +a_missile = Sprite([-10, -10], [0, 0], my_ship.angle, 0, missile_image, missile_info, missile_sound) + +# register handlers +frame.set_draw_handler(draw) +frame.set_keydown_handler(keyd) +frame.set_keyup_handler(keyu) +timer = simplegui.create_timer(1000.0, rock_spawner) + +# get things rolling +timer.start() +frame.start() diff --git a/Stopwatch.py b/Stopwatch.py new file mode 100755 index 0000000..142ddb7 --- /dev/null +++ b/Stopwatch.py @@ -0,0 +1,79 @@ +import simplegui + +# define global variables +global count, min, sec, x, y +count = 0 +sec = 0 +min = 0 +x = 0 +y = 0 +n1 = 0 +n2 = 0 + +# counting tenths of seconds into formatted string A:BC.D +def format(t): + global count, sec, min + t = count + if (t == 10): + sec = sec + 1 + count = 0 + + if (sec == 60): + min = min + 1 + sec = 0 + +# define event handlers for buttons; "Start", "Stop", "Reset" +def start_timer(): + global n1, n2 + if ((n1-n2) == 0): + n1 = n1 + 1 + timer.start() + +def stop_timer(): + global x, y, n1, n2 + if ((n1-n2) == 1): + n2 = n2 + 1 + timer.stop() + y = y + 1 + if (count == 0): + x = x + 1 + +def reset_timer(): + global count, sec, min, x, y + timer.stop() + count = 0 + sec = 0 + min = 0 + x = 0 + y = 0 + +def exit_timer(): + frame.stop() + +# define event handler for timer with 0.1 sec interval +def timer_handler(): + global count + count = count + 1 + +def draw_handler(canvas): + global count, sec, min, x, y + format(count) + if (sec < 10): + canvas.draw_text(str(min)+":"+str(0)+str(sec)+"."+str(count),(70,110),20,"White") + else: + canvas.draw_text(str(min)+":"+str(sec)+"."+str(count),(70,110),20,"White") + canvas.draw_text(str(x)+"/"+str(y), (10,30), 20, "Red") + +# create frame +frame = simplegui.create_frame("Stopwatch:The Game",200,200) + +# register event handlers +timer = simplegui.create_timer(100,timer_handler) +frame.add_button("Start",start_timer,100) +frame.add_button("Stop",stop_timer,100) +frame.add_button("Reset",reset_timer,100) +frame.set_draw_handler(draw_handler) +frame.add_button("Exit Game",exit_timer,100) + +# start timer and frame +frame.start()