pygame ट्यूटोरियल
शुरुआत pygame से हो रही है

टिप्पणियों

संस्करण

एक साधारण 'खेल'

आयात करें और आरंभ करें

हर मॉड्यूल को आयात करने की आवश्यकता है और pygame कोई अपवाद नहीं है। हालाँकि हमें pygame.init() सभी आयातित मॉड्यूल के लिए फ़ंक्शन pygame.init() को ठीक से प्रारंभ करने के लिए कॉल करना होगा। अगर हम इसे भूल जाते हैं तो कुछ मॉड्यूल काम नहीं करेंगे। फ़ंक्शन सभी सफलतापूर्वक और विफल आरंभियों की एक वापसी भी देता है (यदि मॉड्यूल प्रारंभ करने में विफल रहता है तो यह त्रुटि नहीं उठाएगा)।

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))

आवश्यकताएं बनाएं

हमें एक डिस्प्ले बनाने की भी आवश्यकता है। Pygame ने पहले से ही (छिपा हुआ) डिस्प्ले बनाया है, इसलिए हमें केवल प्रदर्शन के मोड को सेट करना है (इस उदाहरण में हम केवल रिज़ॉल्यूशन सेट करते हैं)। यह सुनिश्चित करना भी एक अच्छा विचार है कि एक निश्चित गति से हमारे कार्यक्रम के अपडेट को सुनिश्चित करने के लिए एक घड़ी बनाएं (अन्यथा यह कंप्यूटर कितनी तेज गति के आधार पर अलग-अलग गति से चलेगा)।

screen = pygame.display.set_mode((720, 480))  # Notice the tuple! It's not 2 arguments.
clock = pygame.time.Clock()
FPS = 60  # This variable will define how many frames we update per second.

बाद में हमारे कोड में थोड़ी पठनीयता के लिए हम दो रंग स्थिरांक बनाएंगे, जो लाल, हरे और नीले रंग (RGB) के एक टपल का प्रतिनिधित्व करते हैं। मान 0 (कोई प्रकाश) से 255 (पूर्ण प्रकाश) तक जाते हैं।

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

Pygame में हम आम तौर पर एक सतह का उपयोग एक वस्तु की उपस्थिति का प्रतिनिधित्व करने के लिए, और एक रेक्ट (आयत) एक वस्तु की स्थिति का प्रतिनिधित्व करने के लिए। एक सतह कागज की एक खाली शीट की तरह होती है जिसमें रंग या चित्र होते हैं। आप एक वर्ग बना रहे हैं आप विशेषताओं छवि और कई कार्यों के बाद से रेक्ट के लिए देखो और उन विशेषताओं का उपयोग होगा नाम रखना चाहिए। इस तरह की कक्षाओं इनहेरिट से लाभ होगा pygame.sprite.Sprite कारणों के लिए वर्ग आप पर पढ़ सकते हैं यहाँ ।

rect = pygame.Rect((0, 0), (32, 32))  # First tuple is position, second is size.
image = pygame.Surface((32, 32))  # The tuple represent size.
image.fill(WHITE)  # We fill our surface with a nice white color (by default black).

खेल पाश

अब हमारे पास हमारे गेम लूप के लिए सब कुछ सेट है। यह एक लूप है जो पूरे गेम के लिए चलेगा, जहां हम ईवेंट्स को हैंडल करते हैं और अपनी वस्तुओं की स्क्रीन और स्थिति को अपडेट करते हैं।

पहले हम यह सुनिश्चित करेंगे कि एक दिए गए FPS पर हमारा लूप निष्पादित हो। हमने एफपीएस को परिभाषित किया और कार्यक्रम की शुरुआत में हमारी घड़ी बनाई। निम्नलिखित कोड सुनिश्चित करेगा कि हमारा कार्यक्रम हमारे पाश को उस मात्रा को दोहराने के लिए पर्याप्त समय सोता है जो हमने अपने एफपीएस को परिभाषित किया था। इस उदाहरण में, प्रति सेकंड 60 बार।

clock.tick(FPS)

तब हम घटनाओं को संभाल लेंगे। एक घटना मूल रूप से एक उपयोगकर्ता कार्रवाई है, जैसे कि माउस को हिलाना या एक कुंजी दबाया जाना। Pygame इन सभी घटनाओं को एक कतार में पंजीकृत करेगा जिसे हम pygame.event.get() कहकर प्राप्त करते हैं। हम इस पर पुनरावृत्ति कर सकते हैं और जांच कर सकते हैं कि क्या कोई घटना है जिसे हम संभालना चाहते हैं। घटनाओं में एक प्रकार की विशेषता होती है जिसे हम pygame मॉड्यूल में स्थिरांक के खिलाफ जांच सकते हैं ताकि यह निर्धारित किया जा सके कि यह किस प्रकार की घटना है।

for event in pygame.event.get():
    if event.type == pygame.QUIT:  # The user pressed the close button in the top corner of the window.
        quit()
        # Close the program. Other methods like 'raise SystemExit' or 'sys.exit()'.
        # Calling 'pygame.quit()' won't close the program! It will just uninitialize the modules.

हम यह भी देख सकते हैं कि क्या उपयोगकर्ता ने किसी कुंजी को दबाया है या नहीं यह देखने के लिए if event.type == pygame.KEYDOWN देखें। उस स्थिति में घटना की एक विशेषता कुंजी है जिसे हम यह देखने के लिए देख सकते हैं कि यह किस कुंजी का प्रतिनिधित्व करता है।

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        quit()
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_w:
            rect.move_ip(0, -2)  # Changes the rect's position.
        elif event.key == pygame.K_s:
            rect.move_ip(0, 2)
        elif event.key == pygame.K_a:
            rect.move_ip(-2, 0)
        elif event.key == pygame.K_d:
            rect.move_ip(2, 0)

अब हमें अपनी छवि प्रदर्शित करने की आवश्यकता है। पहले हम अपनी स्क्रीन को पिछले रेंडरिंग से खाली करना चाहते हैं। हम अपनी पूरी स्क्रीन को काले रंग से भरते हैं (कोड को यह देखने के लिए हटा दें कि हम इसे क्यों साफ़ करना चाहते हैं)। फिर हमें स्क्रीन पर अपनी छवि को धूमिल करने की आवश्यकता है। अनिवार्य रूप से ब्लिटिंग का मतलब है छवि को किसी अन्य सतह पर कॉपी करना (हमारे मामले में, स्क्रीन)। अंत में हम स्क्रीन को फ्लिप या अपडेट करते हैं।

जब हम ब्लिटिंग कर रहे हैं तो हम वास्तव में उपयोगकर्ता को कुछ भी प्रदर्शित नहीं कर रहे हैं। इसे एक तरफ कंप्यूटर के रूप में और दूसरे पर उपयोगकर्ता की कल्पना करें। कंप्यूटर स्क्रीन के किनारे पर ( ब्लिट्स ) खींचता है, इसे उपयोगकर्ता की ओर फ़्लिप करता है और फिर दोहराता है।

screen.fill(BLACK)
screen.blit(image, rect)
pygame.display.update()  # Or 'pygame.display.flip()'.

अब हमारे पास एक बुनियादी खेल है! काफी उबाऊ, हाँ, लेकिन आवश्यक हैं! अपने वर्तमान पायथन ज्ञान के साथ इसे संयुक्त करें और आपको कुछ भयानक बनाने में सक्षम होना चाहिए।

पूरा कोड

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))


screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60  # Frames per second.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
# RED = (255, 0, 0), GREEN = (0, 255, 0), BLUE = (0, 0, 255).

rect = pygame.Rect((0, 0), (32, 32))
image = pygame.Surface((32, 32))
image .fill(WHITE)  

while True:
    clock.tick(FPS)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                rect.move_ip(0, -2)
            elif event.key == pygame.K_s:
                rect.move_ip(0, 2)
            elif event.key == pygame.K_a:
                rect.move_ip(-2, 0)
            elif event.key == pygame.K_d:
                rect.move_ip(2, 0)

    screen.fill(BLACK)
    screen.blit(image, rect)
    pygame.display.update()  # Or pygame.display.flip()

थोड़ा सुधार हुआ खेल यांत्रिकी

ध्यान दें कि जब हम कुंजी दबाते हैं तो प्रोग्राम की जाँच करता है कि हम कुंजी दबाए रखते हैं या नहीं। इसे ठीक करने के लिए हम एक वेग चर पेश कर सकते हैं। हम इसे अधिक व्यवस्थित रखने के लिए एक खिलाड़ी वर्ग बना सकते हैं। फ्रेम आश्रित आंदोलन से बचने के लिए (यदि हम एफपीएस को 30 में बदल देंगे तो वस्तुएं आधी गति से चलेंगी) हम अपने चल वस्तुओं के बीच समय गुजारने के लिए समय पर निर्भर आंदोलन का परिचय देते हैं।

import pygame

successes, failures = pygame.init()
print("Initializing pygame: {0} successes and {1} failures.".format(successes, failures))

screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)


class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.image.fill(WHITE)
        self.rect = self.image.get_rect()  # Get rect of some size as 'image'.
        self.velocity = [0, 0]

    def update(self):
        self.rect.move_ip(*self.velocity)


player = Player()
running = True
while running:
    dt = clock.tick(FPS) / 1000  # Returns milliseconds between each call to 'tick'. The convert time to seconds.
    screen.fill(BLACK)  # Fill the screen with background color.

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                player.velocity[1] = -200 * dt  # 200 pixels per second
            elif event.key == pygame.K_s:
                player.velocity[1] = 200 * dt
            elif event.key == pygame.K_a:
                player.velocity[0] = -200 * dt
            elif event.key == pygame.K_d:
                player.velocity[0] = 200 * dt
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_w or event.key == pygame.K_s:
                player.velocity[1] = 0
            elif event.key == pygame.K_a or event.key == pygame.K_d:
                player.velocity[0] = 0

    player.update()

    screen.blit(player.image, player.rect)
    pygame.display.update()  # Or pygame.display.flip()

print("Exited the game loop. Game will quit...")
quit()  # Not actually necessary since the script will exit anyway.

अभी भी कई चीजें हैं जिन्हें इस कोड के बारे में सुधार किया जाना चाहिए। मैं आपको pygame ट्यूटोरियल और रिचर्ड जोन्स द्वारा अधिक गहराई से इस बात को पढ़ने की सलाह दूंगा।

Pygame को स्थापित करना

खिड़कियों पर

1. Http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame पर नेविगेट करें - एक अनौपचारिक साइट, जो क्रिस्टोफ गोहलके आधिकारिक CPython वितरण के लिए ओपन-सोर्स पाइथन पैकेज की विंडो बायनेरी प्रदान करती है ।

2. अपने स्थापित अजगर संस्करण के अनुसार उपयुक्त pygame .whl फ़ाइल डाउनलोड करें। (फ़ाइल को कुछ इस तरह नाम दिया गया है जैसे कि pygame - <pygame version> - <python version> - win32.whl )

3. Daud

    pip install your-pygame-package.whl
   

   अपने टर्मिनल, बैश या कंसोल के अंदर।
   नोट: यदि pip में नहीं पाया जाता PATH चलाने का प्रयास python -m pip install your-pygame-package.whl

4. जांचें कि क्या आप अजगर को एक अजगर मॉड्यूल के रूप में आयात कर सकते हैं

   import pygame
   

   यदि आपको कोई त्रुटि नहीं मिलती है, तो आपने अपने कंप्यूटर पर सही ढंग से pygame स्थापित किया है :)

लिनक्स पर

1. अपना टर्मिनल खोलें और चलाएं

   sudo apt-get install python-pygame
   

   नोट: यह python2 के लिए pygame स्थापित करेगा

2. Pygame को अंदर आयात करने का प्रयास करें

   import pygame
   

   यदि आपको कोई त्रुटि नहीं मिलती है, तो आपने अपने लिनक्स सिस्टम पर pygame को सही ढंग से स्थापित किया है :)

MacOS पर

मैक पर इसे स्थापित करने के दो तरीके हैं:

विधि 1

Pygame डाउनलोड पेज पर जाएं और मैक इंस्टॉलर डाउनलोड करें। इसे चलाएं, और इसे आपके मैक पर Pygame स्थापित करना चाहिए।

विधि 2

होमब्रे स्थापित करें:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

फिर Python 2.7.12 और Pygame को स्थापित करने के लिए Homebrew का उपयोग करें:

brew install python; brew install homebrew/python/pygame

अब अपने टर्मिनल में पायथन चलाएं और import pygame करने का प्रयास करें। यदि यह कुछ नहीं कहता है, तो यह सफलतापूर्वक स्थापित है।

एक प्रदर्शन पर pygame और ड्राइंग आयात करना

शुरू करना

आपको Pygame के साथ आरंभ करने के लिए निम्न कार्य करना चाहिए:

import pygame

यह आकार 640,480 की एक विंडो खोलता है, और इसे स्क्रीन नामक एक चर में संग्रहीत करता है।

विंडो नाम सेट करना

Pygame विंडो के लिए नाम सेट करने के लिए निम्नलिखित सिंटैक्स की आवश्यकता होती है:

pygame.display.set_caption('Name')

स्क्रीन के बारे में

• बिंदु (0,0) स्क्रीन के ऊपरी बाएँ हाथ के कोने पर है।
• x निर्देशांक बाएं से दाएं की ओर बढ़ता है, y निर्देशांक ऊपर से नीचे की ओर बढ़ता है। कार्टेसियन प्लेन पर दाईं ओर का निर्देशांक सकारात्मक होता है और बाईं ओर का भाग नकारात्मक होता है। हालांकि, कार्टेशियन विमान में ऊपरी तरफ का निर्देशांक शीर्ष और सकारात्मक के लिए नकारात्मक है। तल पर। ( नोट : यह माना जाता है कि यदि अंक मूल से लिए गए हैं।)

स्क्रीन को अपडेट करना

आप स्क्रीन पर परिवर्तन करते हैं - जैसे इसे रंग से भरना, या उस पर ड्राइंग करना, तुरंत दिखाई नहीं देना!
तो यह कैसे करना है?
आपको इस फ़ंक्शन को कॉल करना होगा:

pygame.display.update()

रंग की

Pygame में रंग RGB मोड पर काम करता है।
रंग के लिए कोड है:

color_Name = (r,g,b)

• आर लाल के लिए खड़ा है।
• जी का मतलब हरा है
• B का मतलब नीला है।
• तीनों को 0 और 255 के बीच पूर्णांक होना चाहिए, जिसमें 255 सबसे चमकीले और 0 सबसे गहरे रंग के होने चाहिए

चित्रकारी

1. रेखाएँ खींचना

   pygame.draw.lines(screen, color, closed, pointlist, thickness)
   

2. आयत बनाने के लिए

   pygame.draw.rect(screen, color, (x,y,width,height), thickness)
   

3. वृत्त बनाना

   pygame.draw.circle(screen, color, (x,y), radius, thickness)
   

एक पाश में सब कुछ सेट करना

एक लूप बनाने के लिए निम्नलिखित कोड का उपयोग करें:

running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()

Pygame विंडो पर एक आयत खींचना (कोड)

import pygame
background_colour = (255,255,255) # White color
(width, height) = (300, 200) # Screen size
color=(0,0,0) #For retangle
screen = pygame.display.set_mode((width, height)) #Setting Screen
pygame.display.set_caption('Drawing') #Window Name
screen.fill(background_colour)#Fills white to screen
pygame.draw.rect(screen, color, (100,50,30,40), 1) #Drawing the rectangle
pygame.display.update()

#Loop
running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()