بايثون

العاب بايثون مجانية مع واجهه رسومية

تعلم لغة Python من خلال دمج المرح لممارسة ألعاب خفيه وبسيطه مثل لعبة حرب الفضاء و الذاكرة. تتراوح الألعاب من الألعاب الأساسية (التي توضح المفاهيم الأساسية في Python) إلى بعض الألعاب المتقدمة التي توضح مفاهيم الفئات العليا في Python جنبًا إلى جنب مع منطق الفيزياء المطلوب لصنع مثل هذه الألعاب, وهو جانب مهم جداً لفهمه خلال رحلتك التعليمية في البرمجة وصنع برامجك الخاصة في عالم برمجة بايثون.

هناك إجمالي 8 ألعاب مرتبة من الأسهل الى الأكثر تعقيداً ، آخر لعبة تسمى حرب الفضاء أو “Asteroids” لعبة رائعة حقًا للنظر إليها ومراجعة الكود البرمجي الخاص بها.

كيف تقوم بتجربة الكود

ان كنت لاتملك محرر اكواد بايثون تستطيع زيارة الموضوع لتالي, او تستطيع استخدام موقع CodeSkulptor ببساطة انسخ كل كود اللعبة والصقه في محرر CodeSkulptor. ثم انقر فوق الزر “تشغيل” وستبدأ اللعبة

لعبة حجره, ورقه, مقص

# Rock-paper-scissors-lizard-Spock template


# The key idea of this program is to equate the strings
# "rock", "paper", "scissors", "lizard", "Spock" to numbers
# as follows:
#
# 0 - rock
# 1 - Spock
# 2 - paper
# 3 - lizard
# 4 - scissors

#----------------------------------------------------------
#----------------------------------------------------------
#----------------------------------------------------------

import random
import simplegui


# helper functions

def name_to_number(name):
    
    # convert name to number using if/elif/else
    # don't forget to return the result!

    if name == "rock":
        return 0
    elif name == "Spock":
        return 1
    elif name == "paper":
        return 2
    elif name == "lizard":
        return 3
    elif name == "scissors":
        return 4
    else:
        print "Error: Not a valid name" 

#----------------------------------------------------------
#----------------------------------------------------------
        
def number_to_name(number):
    
    # convert number to a name using if/elif/else
    # don't forget to return the result!

    if number == 0:
        return "rock"
    elif number == 1:
        return "Spock" 
    elif number == 2:
        return "paper" 
    elif number == 3:
        return "lizard" 
    elif number == 4:
        return "scissors" 
    else:
        print "Error: Not a valid number" 
    
    
#----------------------------------------------------------    
#----------------------------------------------------------    


def rpsls(player_choice): 
    
    print "------------"
    print "------------"    
    
    print "Player chooses " + player_choice 
    
    player_number = name_to_number(player_choice)
    
	comp_number = random.randrange(0,5)
    
    comp_choice = number_to_name(comp_number)
    
    print "Computer chooses " + comp_choice 
    
    diff = (comp_number - player_number) % 5

    if diff == 1 or diff == 2:
        print "Computer Wins"
    elif diff == 3 or diff == 4:
        print "Player Wins"
    else:
        print "Player and computer tie!"
 

#----------------------------------------------------------
#----------------------------------------------------------
#----------------------------------------------------------    
#----------------------------------------------------------    
    
	
# Event Handlers

def get_input(inp):
	
	if (inp == "rock" or inp == "paper" or inp == "lizard" or 
			inp == "Spock" or inp == "scissors"):		
		rpsls(inp)
	else:
		print "Error: Invalid Input"
	
	


# Creating a Frame

frame = simplegui.create_frame("Rock-paper-scissors-lizard-Spock",200,200)

# Registering Handlers

frame.add_input("Enter your choice: ", get_input,200)	
	
	
# Starting the Frame

frame.start()	
    

	
"""	
# test your code - THESE CALLS MUST BE PRESENT IN YOUR SUBMITTED CODE
rpsls("rock")
rpsls("Spock")
rpsls("paper")
rpsls("lizard")
rpsls("scissors")
"""

# always remember to check your completed program against the grading rubric

تخمين الرقم

# template for "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 math
import simplegui


#------------------------------------------
# declaring global variables
secret_number = 0
num_range = 100
remaining_guesses = 0

#------------------------------------------
# helper function to start and restart the game

def new_game():
    print "----------------------------------------"
    print "----------------------------------------"
    
    print "New game. Range is from 0 to", num_range
    
    global secret_number, remaining_guesses
    
    secret_number = random.randrange(0, num_range)

    remaining_guesses = int( math.ceil(math.log(num_range, 2)) )
    
    print "Total Guesses:", remaining_guesses
    
    
#------------------------------------------
# define event handlers for control panel

def range100():
    # button that changes the range to [0,100) and starts a new game 

    global num_range
    num_range = 100
    new_game()
    
  
def range1000():
    # button that changes the range to [0,1000) and starts a new game     
    
    global num_range
    num_range = 1000
    new_game()
    

def reset():
    new_game()
    
    
def input_guess(guess):
    
    global remaining_guesses
    
    guess = int(guess)
    
    print "Guess was", guess
    
    if guess < secret_number:
        print "Higher!"
    elif guess > secret_number:
        print "Lower!"
    else:
        print "Correct!"
        new_game()
        return
    
    remaining_guesses -= 1
    print ""
    print "Number of remaining guesses is :", remaining_guesses
    
    if remaining_guesses == 0:
        print "You ran out of guesses :(  The secret number was", secret_number
        new_game()

#------------------------------------------
        
# create frame

frame = simplegui.create_frame("Guess the Number", 200, 200)

#------------------------------------------

# register event handlers for control elements and start frame

frame.add_button("Range is [0, 100)", range100, 200)
frame.add_button("Range is [0, 1000)", range1000, 200)
frame.add_input("Enter a guess", input_guess, 200)

frame.add_button("New Game", reset, 200)

#------------------------------------------
# call new_game 
new_game()

#------------------------------------------
# starting the frame
frame.start()
#------------------------------------------




# always remember to check your completed program against the grading rubric

لعبة الساعة

# template for "Stopwatch: The Game"



#-------------------------------------------------
#-------------------------------------------------

# global state

import simplegui


# define global variables
ticks = 0
total_stops = 0
correct_stops = 0

timer_stopped = True

#-------------------------------------------------
#-------------------------------------------------


# define helper function format that converts time
# in tenths of seconds into formatted string A:BC.D
def format(t):
    
    # one tenth of a second
    d = t % 10
    
    # total seconds
    seconds = t // 10

    a = seconds // 60
    
    bc = seconds % 60
    
    c = bc % 10
    b = bc // 10
    
    
    result = str(a) + ":" + str(b) + str(c) + "." + str(d)
    
    return result
    
#-------------------------------------------------    
#-------------------------------------------------

    
# define event handlers for buttons; "Start", "Stop", "Reset"

def start():
    global timer_stopped
    timer.start()
    timer_stopped = False

    
def stop():
    global timer_stopped
    
    if not timer_stopped:
        timer.stop()

        global total_stops, correct_stops

        if ticks % 10 == 0:
            correct_stops += 1

        total_stops += 1
        
        timer_stopped = True
    

def reset():
    global ticks, correct_stops, total_stops, timer_stopped
    ticks = 0
    correct_stops = 0
    total_stops = 0
    timer_stopped = True
    timer.stop()


#-------------------------------------------------    
#-------------------------------------------------


# define event handler for timer with 0.1 sec interval

def increment_ticks():
    global ticks
    ticks += 1


# define draw handler

def draw(canvas):
    canvas.draw_text(format(ticks), [75, 100], 40, "Green")
    canvas.draw_text(str(correct_stops) + "/" + str(total_stops), [270,20], 20, "Red")
  

#-------------------------------------------------    
#-------------------------------------------------
    
    
# create frame

frame = simplegui.create_frame("Stop Watch: The Game", 300, 200)
timer = simplegui.create_timer(100, increment_ticks)

#-------------------------------------------------    
#-------------------------------------------------


# register event handlers

frame.set_draw_handler(draw)

frame.add_button("Start", start, 100)
frame.add_button("Stop", stop, 100)
frame.add_button("Reset", reset, 100)


#-------------------------------------------------    
#-------------------------------------------------

# start frame

frame.start()


#-------------------------------------------------    
#-------------------------------------------------

لعبة بونغ

# Implementation of classic arcade game Pong

# ----------------------------------------------------------------
# ----------------------------------------------------------------
# ----------------------------------------------------------------

import simplegui
import random

# ----------------------------------------------------------------
# ----------------------------------------------------------------

# initialize globals

WIDTH = 600
HEIGHT = 400       
BALL_RADIUS = 20
PAD_WIDTH = 10
PAD_HEIGHT = 80
LEFT = False
RIGHT = True

ball_pos = [0, 0]
ball_vel = [0, 0]

paddle1_pos = 0
paddle2_pos = 0

paddle1_vel = 0
paddle2_vel = 0

score1 = 0
score2 = 0

# ----------------------------------------------------------------
# ----------------------------------------------------------------

# helper function

# initialize ball_pos and ball_vel for new ball 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
    
    ball_pos = [WIDTH // 2, HEIGHT // 2]
    
    vx = random.randrange(120, 240) // 60
    vy = -random.randrange(60, 180) // 60
    
    if direction == LEFT:
        vx = -vx 
    
    ball_vel = [vx, vy]
        
# ----------------------------------------------------------------
# ----------------------------------------------------------------

# define event handlers

def new_game():
    global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel  # these are numbers
    global score1, score2  # these are ints
    
    # initialize these global variables to their default values
    score1 = score2 = 0
    
    paddle1_pos = HEIGHT // 2 - 10
    paddle2_pos = HEIGHT // 2 - 10

    paddle1_vel = 0
    paddle2_vel = 0
    
    spawn_ball(bool(random.randrange(0,2)))
# ----------------------------------------------------------------
    

def draw(canvas):
    global score1, score2, paddle1_pos, paddle2_pos, ball_pos, ball_vel, paddle1_vel, paddle2_vel
        
    # draw mid line and gutters
    canvas.draw_line([WIDTH / 2, 0],[WIDTH / 2, HEIGHT], 3, "purple")	# mid line
    canvas.draw_line([PAD_WIDTH, 0],[PAD_WIDTH, HEIGHT], 1, "red")		# gutters
    canvas.draw_line([WIDTH - PAD_WIDTH, 0],[WIDTH - PAD_WIDTH, HEIGHT], 1, "green")
    
    # draw a circle
    canvas.draw_circle([WIDTH / 2, HEIGHT / 2], 85, 4, "Purple")

        
    
    # update ball    
    ball_pos[0] = ball_pos[0] + ball_vel[0]  
    ball_pos[1] = ball_pos[1] + ball_vel[1]        
    
    # collision with top or bottom wall (just inverse the vertical velocity]
    if (ball_pos[1] - BALL_RADIUS <= 0) or (ball_pos[1] + BALL_RADIUS >= HEIGHT):
        ball_vel[1] = -ball_vel[1]
       
    # draw ball
    canvas.draw_circle(ball_pos, BALL_RADIUS, 13, "Purple")
    canvas.draw_circle(ball_pos, BALL_RADIUS, 7, "White") 
    
        
    # update paddle's vertical position, keep paddle on the screen
     
    if not (((paddle1_pos + paddle1_vel) <= 0) or ((paddle1_pos + paddle1_vel + PAD_HEIGHT) >= HEIGHT)):
        paddle1_pos = paddle1_pos + paddle1_vel 
            
    if not (((paddle2_pos + paddle2_vel) <= 0) or ((paddle2_pos + paddle2_vel + PAD_HEIGHT) >= HEIGHT)):
        paddle2_pos = paddle2_pos + paddle2_vel      
        

    # draw paddles
    canvas.draw_line([0, paddle1_pos],[0, paddle1_pos + PAD_HEIGHT], PAD_WIDTH, "white")
    canvas.draw_line([WIDTH, paddle2_pos],[WIDTH, paddle2_pos + PAD_HEIGHT], PAD_WIDTH, "white")

    
    # determine whether paddle and ball collide    
    
    if (ball_pos[0] - BALL_RADIUS) <= PAD_WIDTH:
        
        # Ball hit paddle1
        if ((ball_pos[1] >= paddle1_pos) and (ball_pos[1] <= (paddle1_pos + PAD_HEIGHT))): 
            
            ball_vel[0] = -ball_vel[0]	
            ball_vel[0] += (ball_vel[0] // 10)
            ball_vel[1] += (ball_vel[1] // 10)
            
        else:
            score2 += 1
            spawn_ball(True)

    elif (ball_pos[0] + BALL_RADIUS) >= (WIDTH - PAD_WIDTH):
        
        # Ball hit paddle2
        if ((ball_pos[1] >= paddle2_pos) and (ball_pos[1] <= (paddle2_pos + PAD_HEIGHT))): 
            
            ball_vel[0] = -ball_vel[0]
            ball_vel[0] += (ball_vel[0] // 10)
            ball_vel[1] += (ball_vel[1] // 10)
            
        else:
            score1 += 1
            spawn_ball(False)
            
    # draw score
    canvas.draw_text(str(score1), [180, 50], 55, "Red") # left player score
    canvas.draw_text(str(score2), [420, 50], 55, "Lime") # right player score          
# ----------------------------------------------------------------
        
        
def keydown(key):
    global paddle1_vel, paddle2_vel
    
    # updating the velocities of paddles
    
    if key == simplegui.KEY_MAP["w"]:
        paddle1_vel -= 4
    elif key == simplegui.KEY_MAP["s"]:
        paddle1_vel += 4
    elif key == simplegui.KEY_MAP["up"]:
        paddle2_vel -= 4
    elif key == simplegui.KEY_MAP["down"]:
        paddle2_vel += 4
   

# ----------------------------------------------------------------

def keyup(key):
    global paddle1_vel, paddle2_vel
    
    # making a paddle motionless
    
    if (key == simplegui.KEY_MAP["w"]) or (key == simplegui.KEY_MAP["s"]):
        paddle1_vel = 0
    elif (key == simplegui.KEY_MAP["up"]) or (key == simplegui.KEY_MAP["down"]):
        paddle2_vel = 0
    
# ----------------------------------------------------------------  
# ----------------------------------------------------------------    


# 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", new_game, 100)

# ----------------------------------------------------------------
# ----------------------------------------------------------------

# start frame
new_game()
frame.start()

لعبة الذاكرة

# implementation of card game - Memory

import simplegui
import random

# --------------------------------------------------------
# --------------------------------------------------------

# global variables

deck = []
exposed = []

card1 = 0
card2 = 0

state = 0
turns = 0

# --------------------------------------------------------
# --------------------------------------------------------

# helper function to initialize globals
def new_game():
    global deck, state, exposed, card1, card2, turns
    
    deck = range(8) + range(8)
    random.shuffle(deck)
    
    exposed = [False for x in deck] 
    
    state = turns = card1 = card2 = 0
    
    
# --------------------------------------------------------
# --------------------------------------------------------

     
# define event handlers
def mouseclick(pos):
    
    card_num = pos[0] // 50
    
    if (exposed[card_num] != True):
        exposed[card_num] = True
        
        global card1, card2, state, turns
        
        if state == 0:
            state = 1
            card1 = card_num
            
        elif state == 1:
            state = 2
            card2 = card_num
            turns += 1
      
        else:
            state = 1
                           
            if (deck[card1] != deck[card2]):
                exposed[card1] = exposed[card2] = False 
                
            card1 = card_num    
    
# --------------------------------------------------------        
        
# cards are logically 50x100 pixels in size    
def draw(canvas):    
    x = 0
    i = 0
    for num in deck:
        if exposed[i] == False:
            canvas.draw_line((x, 0), (x, 100), 2, 'yellow')
            canvas.draw_line((x, 0), (x+50, 0), 200, 'green')
        else:    
            canvas.draw_text(str(num), [x , 90], 115, "red")
        x += 50
        i += 1
    
    label.set_text("Turns = " + str(turns))   

    
# --------------------------------------------------------    
# --------------------------------------------------------    
    
    
# create frame and add a button and labels
frame = simplegui.create_frame("Memory", 800, 100)
frame.add_button("Reset", new_game)
label = frame.add_label("Turns = " + str(turns))

# --------------------------------------------------------

# 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 - 936x384 - source: jfitz.com
CARD_SIZE = (72, 96)
CARD_CENTER = (36, 48)
card_images = simplegui.load_image("http://storage.googleapis.com/codeskulptor-assets/cards_jfitz.png")

CARD_BACK_SIZE = (72, 96)
CARD_BACK_CENTER = (36, 48)
card_back = simplegui.load_image("http://storage.googleapis.com/codeskulptor-assets/card_jfitz_back.png")    


# initialize some useful global variables
in_play = False
outcome = ""
score = 0
message = ""
display_hole_card = False
game_stop = True

# 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.cards_list = []

    def __str__(self):
        ans = "Hand contains "
        for x in self.cards_list:
            ans += str(x) + " "
            
        return ans

    def add_card(self, card):
        self.cards_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_rank = False
        
        for x in self.cards_list:
            r = x.get_rank()
            
            if r == RANKS[0]:
                has_rank = True
                
            value += VALUES[r]

        if has_rank and (value+10 <= 21):
            value += 10
        
        return value
    
    
    def draw(self, canvas, pos):
        for x in self.cards_list:
            x.draw(canvas, pos)
            pos[0] += 100

#---------------------------------------------------------------
            
                
# define deck class 
class Deck:
    def __init__(self):       
        self.cards_list = [Card(s,r) for s in SUITS for r in RANKS]
        
    def shuffle(self):
        random.shuffle(self.cards_list) 

    def deal_card(self):
        return self.cards_list.pop(-1)
    
    def __str__(self):
        ans = "Deck contains "
        for x in self.cards_list:
            ans += str(x) + " "
            
        return ans
        
#---------------------------------------------------------------
#---------------------------------------------------------------
    
    
#define event handlers for buttons
def deal():
    global outcome, in_play, game_deck, player_hand
    global dealer_hand, message, display_hole_card, game_stop, score
    
    if game_stop == False:
        outcome = "You lose."
        score -= 1
        message = "New deal?"
        display_hole_card = True
        game_stop = True
                
    else:
        game_deck = Deck()
        game_deck.shuffle()

        player_hand = Hand()
        dealer_hand = Hand()

        for i in range(2):
            player_hand.add_card( game_deck.deal_card() )
            dealer_hand.add_card( game_deck.deal_card() )    

        in_play = True
        display_hole_card = False
        outcome = ""
        message = "Hit or Stand?"

        game_stop = False

#---------------------------------------------------------------
   
def hit():

    global outcome, score, message, display_hole_card, game_stop
        
    if game_stop == False:
        
        # if the hand is in play, hit the player    
        if in_play:
            if player_hand.get_value() <= 21:
                player_hand.add_card(game_deck.deal_card())

            if player_hand.get_value() > 21:
                outcome = "You went bust and lose."
                message = "New deal?"
                score -= 1
                display_hole_card = True
                game_stop = True
        else:
            dealer_hand.add_card(game_deck.deal_card())
#---------------------------------------------------------------
        
def stand():

    global in_play, outcome, score, message, display_hole_card, game_stop
    
    if game_stop == False:

        message = "New deal?"
        in_play = False

        display_hole_card = True

        # repeatedly hit dealer until his hand has value 17 or more
        while (dealer_hand.get_value() < 17):
            hit()

        if dealer_hand.get_value () > 21:
            outcome = "You won."
            score += 1

        else:
            if player_hand.get_value() <= dealer_hand.get_value():
                outcome = "You lose."
                score -= 1        

            else:
                outcome = "You won."
                score += 1

        game_stop = True
#---------------------------------------------------------------
#---------------------------------------------------------------

                                                                                              
# draw handler    
def draw(canvas):
   
    canvas.draw_text("Blackjack", [100, 100], 50,  "Red")
    canvas.draw_text("Score: " + str(score), [400, 100], 40,  "yellow")
    
    canvas.draw_text("Dealer", [40, 200], 40,  "Black")      
    canvas.draw_text("Player", [40, 400], 40,  "Black")                                       

    canvas.draw_text(outcome, [250, 200], 35,  "Black")                                       
    canvas.draw_text(message, [300, 400], 40,  "Black")                                       
    
    player_hand.draw(canvas, [50, 440])
    dealer_hand.draw(canvas, [50, 230])
    
    if display_hole_card == False:
        canvas.draw_image(card_back, CARD_BACK_CENTER, CARD_BACK_SIZE
                          , [50 + CARD_CENTER[0], 230 + CARD_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)
#-----------------------------------------------------------------

# defining global objects
game_deck = Deck()
player_hand = Hand()
dealer_hand = Hand()
#-----------------------------------------------------------------
                                 
# get things rolling
deal()
frame.start()

سفينة الفضاء

#--------------------------------------------------------
#--------------------------------------------------------
# miniproject 7 - Spaceship
import simplegui
import math
import random

#--------------------------------------------------------


# helper functions and classes


# class which contains information for an image
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.f2014.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")

# alternative upbeat soundtrack by composer and former IIPP student Emiel Stopler
# please do not redistribute without permission from Emiel at http://www.filmcomposer.nl
#soundtrack = simplegui.load_sound("https://storage.googleapis.com/codeskulptor-assets/ricerocks_theme.mp3")



# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------




#--------------------------------------------------------
# globals for user interface
WIDTH = 800
HEIGHT = 600
score = 0
lives = 3
time = 0

FRICTION_CONSTANT = 0.05

#---------------------------------------------------------




# 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
        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()
        
    def draw(self,canvas):
        if self.thrust:
            canvas.draw_image(self.image, [self.image_center[0]+90, self.image_center[1]],
                              self.image_size, self.pos, self.image_size, self.angle)
            
            ship_thrust_sound.play()
            
        else:    
            canvas.draw_image(self.image, self.image_center, self.image_size, self.pos, self.image_size, self.angle)
            ship_thrust_sound.rewind()
            
            
    # motion control scheme for the spaceship        
    def update(self):        
        self.angle += self.angle_vel

        self.pos[0] += self.vel[0]
        self.pos[1] += self.vel[1]

        self.pos[0] %= WIDTH
        self.pos[1] %= HEIGHT

        self.vel[0] *= (1-FRICTION_CONSTANT)
        self.vel[1] *= (1-FRICTION_CONSTANT)
        
        if self.thrust:
            forward_thrust = angle_to_vector(self.angle)

            self.vel[0] += (forward_thrust[0])/2
            self.vel[1] += (forward_thrust[1])/2            
            
     
    def shoot(self):
        global a_missile
        
        forward_vector = angle_to_vector(self.angle)

        missile_pos = [0,0]

        missile_pos[0] = self.pos[0] + self.radius * forward_vector[0]
        missile_pos[1] = self.pos[1] + self.radius * forward_vector[1]
                
        
        missile_vel = [0, 0]
        missile_vel[0] = self.vel[0] + (forward_vector[0]*5)
        missile_vel[1] = self.vel[1] + (forward_vector[1]*5)
        
        a_missile = Sprite(missile_pos, missile_vel, 0, 0, missile_image, missile_info, missile_sound)    

                
# -----------------------------------------------------------------------------    
    
# 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.angle += self.angle_vel

        self.pos[0] += self.vel[0]
        self.pos[1] += self.vel[1]

        self.pos[0] %= WIDTH
        self.pos[1] %= HEIGHT        


# -----------------------------------------------------------------------------    
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------


# event handlers

def draw(canvas):
    global time
    
    # 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))

    # 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()
    
    # draw lives and score
    canvas.draw_text("Lives: " + str(lives), [WIDTH - 120, 40], 30, "white")
    canvas.draw_text("Score: " + str(score), [WIDTH - 120, 80], 30, "white")

# -----------------------------------------------------------------------------    
     
# key handlers

def keydown(key):
    
    if key == simplegui.KEY_MAP["left"]:
        my_ship.angle_vel = -0.1
    elif key == simplegui.KEY_MAP["right"]:
        my_ship.angle_vel = 0.1        
    elif key == simplegui.KEY_MAP["up"]:
        my_ship.thrust = True
    elif key == simplegui.KEY_MAP["space"]:
        my_ship.shoot()
    
    
def keyup(key):
    
    if (key == simplegui.KEY_MAP["left"]) or (key == simplegui.KEY_MAP["right"]):
        my_ship.angle_vel = 0
    elif key == simplegui.KEY_MAP["up"]:
        my_ship.thrust = False
    
    
# -----------------------------------------------------------------------------    
           
# timer handler that spawns a rock    
def rock_spawner():
    global a_rock
    
    width = random.randrange(WIDTH)
    height = random.randrange(HEIGHT)
    
    vel = [0, 0]
    vel[0] = random.randrange(2)
    vel[1] = random.randrange(2)
    
    ang = random.random()
    ang_vel = random.random() - 0.5
    
    a_rock = Sprite([width, height], vel, ang, ang_vel, asteroid_image, asteroid_info)

    
# -----------------------------------------------------------------------------

    
# initialize frame
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)

# -----------------------------------------------------------------------------

# initialize ship and two sprites
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info)
a_rock = Sprite([WIDTH / 3, HEIGHT / 3], [1, 1], 0, 0, asteroid_image, asteroid_info)
a_missile = Sprite([2 * WIDTH / 3, 2 * HEIGHT / 3], [-1,1], 0, 0, missile_image, missile_info, missile_sound)


# -----------------------------------------------------------------------------

# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)

timer = simplegui.create_timer(1000.0, rock_spawner)



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

لعبة الكويكبات

#-------------------------------------------------------------------

# implementation of Spaceship - program template for RiceRocks
import simplegui
import math
import random

#-------------------------------------------------------------------


# helper classes

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.f2014.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
# .ogg versions of sounds are also available, just replace .mp3 by .ogg
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")
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")

# alternative upbeat soundtrack by composer and former IIPP student Emiel Stopler
# please do not redistribute without permission from Emiel at http://www.filmcomposer.nl
#soundtrack = simplegui.load_sound("https://storage.googleapis.com/codeskulptor-assets/ricerocks_theme.mp3")


#-------------------------------------------------------------------
#-------------------------------------------------------------------
#-------------------------------------------------------------------


# globals for user interface
WIDTH = 800
HEIGHT = 600
score = 0
lives = 3
time = 0
started = False

#-------------------------------------------------------------------
#-------------------------------------------------------------------


# 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)

def process_sprite_group(s_group, canvas):
    for x in set(s_group):
        x.draw(canvas)
        if x.update():
            s_group.remove(x)

            
def group_collide(s_group, other_object):
    has_collide = False
    
    for x in set(s_group):
        if (x.collide(other_object)):
            a_explosion = Sprite(x.get_position(), [0, 0], 0, 0, explosion_image, explosion_info, explosion_sound)
            explosion_group.add(a_explosion)
            s_group.remove(x)
            has_collide = True

    return has_collide


def group_group_collide(group1, group2):
    total_collisions = 0
    
    for x in set(group1):
        if group_collide(group2, x):
            group1.discard(x)
            total_collisions += 1
            
    return total_collisions
        
#-------------------------------------------------------------------
# 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
        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()

    def get_position(self):
        return self.pos

    def get_radius(self):
        return self.radius        
        
    def draw(self,canvas):
        if self.thrust:
            canvas.draw_image(self.image, [self.image_center[0] + self.image_size[0], self.image_center[1]] , 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):
        # update angle
        self.angle += self.angle_vel
        
        # update position
        self.pos[0] = (self.pos[0] + self.vel[0]) % WIDTH
        self.pos[1] = (self.pos[1] + self.vel[1]) % HEIGHT

        # update velocity
        if self.thrust:
            acc = angle_to_vector(self.angle)
            self.vel[0] += acc[0] * .1
            self.vel[1] += acc[1] * .1
            
        self.vel[0] *= .99
        self.vel[1] *= .99

    def set_thrust(self, on):
        self.thrust = on
        if on:
            ship_thrust_sound.rewind()
            ship_thrust_sound.play()
        else:
            ship_thrust_sound.pause()
       
    def increment_angle_vel(self):
        self.angle_vel += .05
        
    def decrement_angle_vel(self):
        self.angle_vel -= .05
        
    def shoot(self):
        forward = angle_to_vector(self.angle)
        missile_pos = [self.pos[0] + self.radius * forward[0], self.pos[1] + self.radius * forward[1]]
        missile_vel = [self.vel[0] + 6 * forward[0], self.vel[1] + 6 * forward[1]]
        a_missile = Sprite(missile_pos, missile_vel, self.angle, 0, missile_image, missile_info, missile_sound)
        
        missile_group.add(a_missile)
        
#-------------------------------------------------------------------
#-------------------------------------------------------------------
    
# 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 get_position(self):
        return self.pos

    def get_radius(self):
        return self.radius
        
    def draw(self, canvas):
        if self.animated:
            canvas.draw_image(self.image, [self.image_center[0] + self.age*self.image_size[0] ,self.image_center[1]] , 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):
        # update angle
        self.angle += self.angle_vel
        
        # update position
        self.pos[0] = (self.pos[0] + self.vel[0]) % WIDTH
        self.pos[1] = (self.pos[1] + self.vel[1]) % HEIGHT
    
        self.age += 1    
        return (self.age >= self.lifespan)
           
        
    def collide(self,other_object):
        return ( dist(self.get_position(), other_object.get_position()) <= (self.radius + other_object.radius) )

#-------------------------------------------------------------------
#-------------------------------------------------------------------

# key handlers to control ship   
def keydown(key):
    if key == simplegui.KEY_MAP['left']:
        my_ship.decrement_angle_vel()
    elif key == simplegui.KEY_MAP['right']:
        my_ship.increment_angle_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.increment_angle_vel()
    elif key == simplegui.KEY_MAP['right']:
        my_ship.decrement_angle_vel()
    elif key == simplegui.KEY_MAP['up']:
        my_ship.set_thrust(False)

#-------------------------------------------------------------------
#-------------------------------------------------------------------
        
# mouseclick handlers that reset UI and conditions whether splash image is drawn
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:
        started = True
        lives = 3
        score = 0
        soundtrack.rewind()
        soundtrack.play()

        
#-------------------------------------------------------------------
#-------------------------------------------------------------------
def draw(canvas):
    global time, started, lives, score, rock_group
    
    # 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))

    # draw UI
    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")

    # draw and update ship and sprites
    my_ship.draw(canvas)    
    my_ship.update()
        
    process_sprite_group(rock_group,canvas)
    process_sprite_group(missile_group,canvas)
    process_sprite_group(explosion_group,canvas)
    
    # update lives
    if group_collide(rock_group, my_ship):
        lives -= 1
        
    # update score
    score += group_group_collide(rock_group, missile_group)
     
    if lives == 0:
        started = False
        rock_group = set()
        
        
    # 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    
def rock_spawner():
    
    if started:
        if len(rock_group) != 12:
            rock_pos = [random.randrange(0, WIDTH), random.randrange(0, HEIGHT)]
            
            if not (dist(my_ship.get_position(), rock_pos) <= 10):
                rock_vel = [(random.random() * .6 - .3) + score/5.0 , (random.random() * .6 - .3) + score/5.0]
                rock_avel = random.random() * .2 - .1
                a_rock = Sprite(rock_pos, rock_vel, 0, rock_avel, asteroid_image, asteroid_info)

                rock_group.add(a_rock)

#-------------------------------------------------------------------
#-------------------------------------------------------------------
        
# initialize stuff
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)

#-------------------------------------------------------------------

# initialize ship and two sprites
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info)
rock_group = set([])
missile_group = set([])
explosion_group = set([])
#-------------------------------------------------------------------


# register handlers
frame.set_keyup_handler(keyup)
frame.set_keydown_handler(keydown)
frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)
#-------------------------------------------------------------------

timer = simplegui.create_timer(1000.0, rock_spawner)

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

تحميل الأكواد بملف واحد

تستطيع تحميل ملفات الأكواد كاملة مره واحده بدلاً من نسخ ولصق الأكواد في الأعلى ان كنت تريد تحميلهم وقراءة اعمق لطريقة عمل الأكواد

مقالات ذات صلة

اترك تعليقاً

لن يتم نشر عنوان بريدك الإلكتروني. الحقول الإلزامية مشار إليها بـ *

أنت تستخدم إضافة Adblock

ادعمنا بإيقاف مانع الأعلانات من فضلك