pygame
स्क्रीन पर ड्राइंग

वाक्य - विन्यास

• pygame.draw.rect (सतह, रंग, अनुपात, चौड़ाई = 0)
• pygame.draw.polygon (सतह, रंग, बिंदु सूची, चौड़ाई = 0)
• pygame.draw.circle (सतह, रंग, स्थिति, त्रिज्या, चौड़ाई = 0)
• pygame.draw.ellipse (सतह, रंग, अनुपात, चौड़ाई = 0)
• pygame.draw.arc (सरफेस, कलर, रेक्ट, स्टार्ट_एंगल, स्टॉप_एंगल, चौड़ाई = 1)
• pygame.draw.line (सतह, रंग, start_pos, end_pos, width = 1)
• pygame.draw.lines (सतह, रंग, बंद, पॉइंटलिस्ट, चौड़ाई = 1)
• pygame.draw.aaline (सतह, रंग, प्रारंभ, समाप्ति, मिश्रण = 1)
• pygame.draw.aalines (सतह, रंग, बंद, बिंदुसूची, मिश्रण = 1)

पैरामीटर

ड्रा मॉड्यूल के साथ ड्राइंग

Pygame में एक मॉड्यूल, pygame.draw , जिसमें फ़ंक्शंस होते हैं जो सीधे सरफेस पर आकृतियाँ बना सकते हैं।

मॉड्यूल का उपयोग कैसे करें

मॉड्यूल का उपयोग करने के लिए आपको पहले pygame को सही ढंग से आयात और प्रारंभ करना होगा और प्रदर्शन के लिए एक मोड सेट करना होगा। रंग कोड को पहले से परिभाषित करना सुविधाजनक है, जिससे आपका कोड अधिक पठनीय और अधिक सुंदर हो जाता है। सभी फ़ंक्शंस ड्रा करने के लिए एक सरफेस लेते हैं, एक रंग और एक स्थिति तर्क जो या तो एक pygame रेक्ट या 2-तत्व पूर्णांक / फ्लोट अनुक्रम ( pygame.draw.circle केवल अपरिभाषित कारणों के कारण पूर्णांक लेगा)।

उदाहरण

नीचे दिए गए कोड में सभी विभिन्न कार्यों का प्रदर्शन किया जाएगा, उनका उपयोग कैसे किया जाता है और वे कैसे दिखते हैं। हम pygame को इनिशियलाइज़ करेंगे और उदाहरणों से पहले कुछ स्थिरांक परिभाषित करेंगे।

import pygame
from math import pi
pygame.init()

screen = pygame.display.set_mode((100, 100))
WHITE = pygame.Color(255, 255, 255)
RED = pygame.Color(255, 0, 0) 

काला रंग सर्फेस डिफॉल्ट रंग है और सरफेस के उस हिस्से का प्रतिनिधित्व करता है जिसे खींचा नहीं गया है। प्रत्येक फ़ंक्शन के मापदंडों को नीचे पैरामीटर में समझाया गया है।

रेक्ट

size = (50, 50)

rect_border = pygame.Surface(size)  # Create a Surface to draw on.
pygame.draw.rect(rect_border, RED, rect_border.get_rect(), 10)  # Draw on it.

rect_filled = pygame.Surface(size)
pygame.draw.rect(rect_filled, RED, rect_filled.get_rect())   

बहुभुज

size = (50, 50)
points = [(25, 0), (50, 25), (25, 50), (0, 25)]  # The corner points of the polygon.

polygon = pygame.Surface(size)
pygame.draw.polygon(polygon, RED, points, 10)

polygon_filled = pygame.Surface(size)
pygame.draw.polygon(polygon_filled, RED, points)

वृत्त

size = (50, 50)
radius = 25

circle = pygame.Surface(size)
pygame.draw.circle(circle, RED, (radius, radius), radius, 10)  # Position is the center of the circle.

circle_filled = pygame.Surface(size)
pygame.draw.circle(circle_filled, RED, (radius, radius), radius)

छेद pygame के ड्राइंग एल्गोरिदम का एक दुर्भाग्यपूर्ण परिणाम है।

अंडाकार

size = (50, 25)  # Minimize it's height so it doesn't look like a circle.

ellipse = pygame.Surface(size)  
pygame.draw.ellipse(ellipse, RED, ellipse.get_rect(), 5)

ellipse_filled = pygame.Surface(size)
pygame.draw.ellipse(ellipse_filled, RED, ellipse.get_rect())

छेद pygame के ड्राइंग एल्गोरिदम का एक दुर्भाग्यपूर्ण परिणाम है।

आर्क

size = (50, 50)

arc = pygame.Surface(size)
pygame.draw.arc(arc, RED, arc.get_rect(), 0, pi)  # 0 to pi is 180° creating a half circle.

लाइन

size = (50, 50)

line = pygame.Surface(size)
pygame.draw.line(line, RED, (0, 0), (50, 50))  # Start at topleft and ends at bottomright.

पंक्तियां

size = (50, 50)
points = [(25, 0), (50, 25), (25, 50), (0, 25)]

lines = pygame.Surface(size)
pygame.draw.lines(lines, RED, False, points)

lines_closed = pygame.Surface(size)
pygame.draw.lines(lines_closed, RED, True, points)

एंटीअलियासिड लाइन

size = (50, 50)

antialiased_line = pygame.Surface(size)
pygame.draw.aaline(antialiased_line, RED, (0, 0), (50, 50))

एंटीअलियासिड लाइनें

size = (50, 50)
points = [(25, 0), (50, 25), (25, 50), (0, 25)]

antialiased_lines = pygame.Surface(size)
pygame.draw.aalines(antialiased_lines, RED, False, points)

antialiased_lines_closed = pygame.Surface(size)
pygame.draw.aalines(antialiased_lines_closed, RED, True, points)

कोशिश करके देखो

इसे अपने लिए आज़माने के लिए: ऊपर दिए गए कोड स्निपेट और खाली फ़ाइल में दिए कोड में से किसी एक को कॉपी करें, उस नाम की छवि को उस सतह के नाम में बदलें जिसे आप ब्लिट करना चाहते हैं और प्रयोग करना चाहते हैं।

import pygame
from math import pi
pygame.init()

screen = pygame.display.set_mode((100, 100))
WHITE = pygame.Color(255, 255, 255)
RED = pygame.Color(255, 0, 0) 

# But code snippet here

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
    
    screen.blit(image, (25, 25))
    pygame.display.update()

सतहों

Pygame में आप आमतौर पर वस्तुओं की उपस्थिति का प्रतिनिधित्व करने के लिए सतहों का उपयोग करते हैं, और आयतों को उनके पदों का प्रतिनिधित्व करने के लिए। एक सतह कागज की एक खाली शीट की तरह होती है जिसमें रंग या चित्र होते हैं। सरफेस बनाने के दो तरीके हैं: स्क्रैच से खाली या इमेज लोड करके।

एक सतह बनाएँ

सरफेस बनाने के लिए आपको न्यूनतम आकार की आवश्यकता होती है, जो कि चौड़ाई और ऊंचाई का 2-तत्व पूर्णांक अनुक्रम है, जो पिक्सेल में आकार का प्रतिनिधित्व करता है।

जब आप बिट की गहराई, मास्क और अतिरिक्त सुविधाओं को पिक्सेल पिक्सेल अल्फा और / या वीडियो मेमोरी में छवि बनाने के लिए सतह बनाने के लिए अतिरिक्त तर्क पास कर सकते हैं। हालांकि यह इस उदाहरण के दायरे से बाहर है।

size = width, height = (32, 32)
empty_surface = pygame.Surface(size)

आप भूतल पर आकृतियों को आकर्षित करने के लिए pygame.draw मॉड्यूल का उपयोग कर सकते हैं, या सतह विधि fill(color) कहकर इसे रंग से fill(color) । तर्क रंग 3 या 4-तत्व पूर्णांक अनुक्रम या pygame.Color ऑब्जेक्ट है।

एक छवि लोड करें

अधिक बार आप एक गेम (स्प्राइट्स) में अपनी खुद की छवियों का उपयोग नहीं करना चाहेंगे। आपकी छवि के साथ एक सरफेस बनाना उतना ही आसान है:

my_image = pygame.image.load(path_to_image)

छवि का मार्ग सापेक्ष या निरपेक्ष हो सकता है। प्रदर्शन में सुधार करने के लिए आमतौर पर अपनी छवि को स्क्रीन के समान पिक्सेल प्रारूप में बदलना बुद्धिमानी है। यह सरफेस मेथड convert() को कॉल करके किया जा सकता है, जैसे:

my_image = pygame.image.load(path_to_image).convert()

यदि आपकी छवि में पारदर्शिता है (अल्फा मान) तो आप इसके बजाय विधि convert_alpha() कॉल करते हैं:

my_image = pygame.image.load(path_to_image).convert_alpha()

Blitting

उन्हें प्रदर्शित करने में सक्षम होने के लिए सतहों को स्क्रीन पर ब्लिट करने की आवश्यकता है। ब्लिटिंग का मतलब है एक सतह से दूसरे पर पिक्सेल की प्रतिलिपि बनाना (स्क्रीन सरफेस भी है)। आपको सतह की स्थिति को भी पास करना होगा, जिसमें 2-तत्व पूर्णांक अनुक्रम या एक रेक्ट ऑब्जेक्ट होना चाहिए। भूतल के ऊपरी हिस्से को स्थिति में रखा जाएगा।

screen.blit(my_image, (0, 0))
pygame.display.update()  # or pygame.display.flip()

स्क्रीन की तुलना में अन्य सतहों पर ब्लिट करना संभव है। यह दिखाने के लिए कि स्क्रीन पर क्या pygame.display.update() आपको pygame.display.update() या pygame.display.flip() कॉल pygame.display.update() ।

पारदर्शिता

Pygame में समर्थित पारदर्शिता के 3 प्रकार हैं: colorkeys, भूतल अल्फ़ाज़, और प्रति पिक्सेल अल्फ़ाज़।

Colorkeys

एक रंग को पूरी तरह से पारदर्शी बनाता है, या अधिक सटीक रूप से, एक रंग बना देता है जो केवल धूमिल नहीं होता है। यदि आपके पास एक काली रेक्ट वाली छवि है, तो आप काले रंग को धुंधला होने से रोकने के लिए एक कॉलोर्के सेट कर सकते हैं।

BLACK = (0, 0, 0)
my_image.set_colorkey(BLACK)  # Black colors will not be blit.

एक भूतल में केवल एक ही कॉर्क हो सकता है। एक और कॉलोर्के स्थापित करने से पिछले ओवरराइट हो जाएंगे। Colorkeys में अलग-अलग अल्फ़ा मान नहीं हो सकते हैं, यह केवल एक रंग को दिखाई नहीं दे सकता है।

सतह अल्फ़ाज़

अल्फा वैल्यू द्वारा पूरे सरफेस को पारदर्शी बनाता है। इस पद्धति के साथ आपके पास अलग-अलग अल्फा मान हो सकते हैं लेकिन यह संपूर्ण सरफेस को प्रभावित करेगा।

my_image.set_alpha(100)  # 0 is fully transparent and 255 fully opaque.

प्रति पिक्सेल अल्फा

सतह के प्रत्येक पिक्सेल को एक अलग-अलग अल्फा मान द्वारा पारदर्शी बनाता है। यह आपको सबसे अधिक स्वतंत्रता और लचीलापन देता है, लेकिन सबसे धीमी विधि भी है। इस पद्धति के लिए सतह को प्रति पिक्सेल अल्फा सरफेस के रूप में भी बनाने की आवश्यकता होती है, और रंग तर्कों को चौथे अल्फा पूर्णांक को समाहित करने की आवश्यकता होती है।

size = width, height = (32, 32)
my_image = pygame.Surface(size, pygame.SRCALPHA)  # Creates an empty per-pixel alpha Surface.

यदि रंग में चौथा अल्फा मान है, तो सरफेस अब पारदर्शिता आकर्षित करेगा।

BLUE = (0, 0, 255, 255)
pygame.draw.rect(my_image, BLUE, my_image.get_rect(), 10)

अन्य सतहों के विपरीत, यह सरफेस डिफॉल्ट रंग काला नहीं बल्कि पारदर्शी होगा। इसलिए बीच में काली आयत गायब हो जाती है।

कोलोर्की और सरफेस अल्फा को मिलाएं

Colorkeys और भूतल अक्षों को जोड़ा जा सकता है, लेकिन प्रति पिक्सेल अल्फा नहीं हो सकता। यह उपयोगी हो सकता है यदि आप प्रति पिक्सेल सतह का धीमा प्रदर्शन नहीं चाहते हैं।

purple_image.set_colorkey(BLACK)
purple_image.set_alpha(50)

पूर्ण कोड

इसे एक खाली फाइल में कॉपी करें और रन करें। छवियों को प्रदर्शित करने के लिए चाबियाँ 1, 2, 3 या 4 दबाएं। उन्हें अधिक अपारदर्शी बनाने के लिए कई बार 2, 3 या 4 दबाएं।

import pygame
pygame.init()

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255, 50)  # This color contains an extra integer. It's the alpha value.
PURPLE = (255, 0, 255)

screen = pygame.display.set_mode((200, 325))
screen.fill(WHITE)  # Make the background white. Remember that the screen is a Surface!
clock = pygame.time.Clock()

size = (50, 50)
red_image = pygame.Surface(size)
green_image = pygame.Surface(size)
blue_image = pygame.Surface(size, pygame.SRCALPHA)  # Contains a flag telling pygame that the Surface is per-pixel alpha
purple_image = pygame.Surface(size)

red_image.set_colorkey(BLACK)
green_image.set_alpha(50)
# For the 'blue_image' it's the alpha value of the color that's been drawn to each pixel that determines transparency.
purple_image.set_colorkey(BLACK)
purple_image.set_alpha(50)

pygame.draw.rect(red_image, RED, red_image.get_rect(), 10)
pygame.draw.rect(green_image, GREEN, green_image.get_rect(), 10)
pygame.draw.rect(blue_image, BLUE, blue_image.get_rect(), 10)
pygame.draw.rect(purple_image, PURPLE, purple_image.get_rect(), 10)

while True:
    clock.tick(60)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_1:
                screen.blit(red_image, (75, 25))
            elif event.key == pygame.K_2:
                screen.blit(green_image, (75, 100))
            elif event.key == pygame.K_3:
                screen.blit(blue_image, (75, 175))
            elif event.key == pygame.K_4:
                screen.blit(purple_image, (75, 250))

    pygame.display.update()