पायथन में स्नेक गेम कैसे बनाएं, Snake Game in Python

Snake Game in Python: यदि आप उन लोगों में से हैं जो सांपों का खेल खेलना पसंद करते हैं, तो मुझे यकीन है कि आपको यह लेख आकर्षक लगेगा। इस लेख में, मैं आपको एक बुनियादी खेल में आने की प्रक्रिया के माध्यम से मार्गदर्शन करूँगा जो कि पायथन में एक नौसिखिए को भी बनाने में सरल लगेगा।

गेम डिज़ाइन करने के कई तरीके हैं, और उनमें से एक है Python में PyGame लाइब्रेरी का उपयोग करना जो एक Python लाइब्रेरी है जिसका उपयोग हम गेम बनाने के लिए करते हैं। एक और तरीका टर्टल लाइब्रेरी का उपयोग करके है।

कछुआ पुस्तकालय पायथन में पहले से स्थापित है और एक ऑनलाइन कैनवास प्रदान करता है जो उपयोगकर्ताओं को आकृतियाँ बनाने और चित्र बनाने की अनुमति देता है।

इसलिए, इस लेख में, हम अपना मूल स्नेक गेम बनाने के लिए टर्टल लाइब्रेरी का उपयोग करेंगे, जो शुरुआती लोगों, विशेषकर पायथन डेवलपर्स के लिए उपयुक्त है।

Snake Game in Python

इस मॉड्यूल के अलावा हम दो अन्य मॉड्यूल का भी उपयोग करेंगे

समय मॉड्यूल। यह तकनीक हमें पिछली बार से गुजरे सेकंड की संख्या को ट्रैक करने की अनुमति देती है।
रैंडम मॉड्यूल: यह पायथन में यादृच्छिक संख्या उत्पन्न करता है।

आपके लिए आवश्यक अन्य आवश्यक उपकरण आपके द्वारा पसंद किए जाने वाले पाठ के लिए एक संपादक हैं। मैं इस पोस्ट में VSCode का उपयोग करूँगा।

बेशक, आपको अपने कंप्यूटर पर Python 3 को सेट अप करने की आवश्यकता होगी यदि यह पहले से नहीं है। Geekflare Compiler का उपयोग करना भी संभव है। गीकफ्लेयर कंपाइलर।

सांपों का खेल, यह एक सुखद अनुभव माना जाता है!

खेल का मुख्य उद्देश्य स्क्रीन पर प्रदर्शित होने वाले भोजन को इकट्ठा करने के लिए सांप को प्रबंधित करके उच्चतम स्कोर अर्जित करना है।

सांप को खिलाड़ी द्वारा नियंत्रित किया जाता है जो दिशा के लिए चार चाबियों का उपयोग करता है जो उस दिशा में दिशात्मक होते हैं जिसमें सांप Snake Game की ओर जाता है। अगर सांप किसी वस्तु या खिलाड़ी पर हमला करता है तो खिलाड़ी खेल हार जाता है।

अगला कदम हम गेम खेलने के लिए उठाएंगे।

  • हमारे अनुप्रयोगों में आयात करना मॉड्यूल जो पूर्व-स्थापित हैं (टर्टल समय, समय, साथ ही यादृच्छिक)।
  • इस कछुआ कार्यक्रम के साथ खेल की स्क्रीन बनाना।
  • स्क्रीन के चारों ओर साँप की गति की दिशा को नियंत्रित करने के लिए कुंजियों को सेट करें।
  • खेल का कार्यान्वयन।
  • एक स्नेकगेम.पी फाइल बनाएं जिसमें हम एक कार्यान्वयन कार्यक्रम जोड़ेंगे।

मॉड्यूल आयात करना | Snake Game in Python

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

अधिकतम स्कोर जो खिलाड़ी प्राप्त कर सकता है और साथ ही प्रत्येक चाल के दौरान खिलाड़ी द्वारा आवश्यक देरी की अवधि। देरी की मात्रा की गणना करने के लिए इस उद्देश्य के लिए समय मॉड्यूल का उपयोग किया जाता है।

स्नेकगेम.py फ़ाइल में निम्नलिखित निर्देश शामिल करें।

import turtle
import random
import time

player_score = 0
highest_score = 0
delay_time = 0.1

खेल की स्क्रीन बनाना | Making the game’s screen

हमारे द्वारा डाउनलोड किया जाने वाला कछुआ प्रोग्राम हमें एक वर्चुअल स्क्रीन बनाने की अनुमति देता है जो कि गेम की विंडोज़ स्क्रीन है।

फिर हम साँप के शरीर का निर्माण कर सकते हैं, साथ ही उन खाद्य पदार्थों का भी निर्माण कर सकते हैं जिन्हें साँप एकत्रित करेगा। स्क्रीन खिलाड़ी का ट्रैकर स्कोर भी दिखाएगा।

# window screen created
wind = turtle.Screen()
wind.title("Snake Maze")
wind.bgcolor("red")

# The screen size
wind.setup(width=600, height=600)


# creating the snake 
snake = turtle.Turtle()
snake.shape("square")
snake.color("black")
snake.penup()
snake.goto(0, 0)
snake.direction = "Stop"

# creating the food
snake_food = turtle.Turtle()
shapes = random.choice('triangle','circle')
snake_food.shape(shapes)
snake_food.color("blue")
snake_food.speed(0)
snake_food.penup()
snake_food.goto(0, 100)

pen = turtle.Turtle()
pen.speed(0)
pen.shape('square')
pen.color('white')
pen.penup()
pen.hideturtle()
pen.goto(0, 250)
pen.write("Your_score: 0 Highest_Score : 0", align="center", 
font=("Arial", 24, "normal"))
turtle.mainloop()

उपरोक्त स्निपेट में कोड कछुए की स्क्रीन के इनिशियलाइज़ेशन के साथ शुरू होता है। यह तब हमारी स्क्रीन पर पृष्ठभूमि के लिए शीर्षक और रंग पास करता है। आकार निर्धारित करने के बाद, हम अपने आभासी कैनवास पर साँप का रूप बनाते हैं।

यह पेनअप () विधि कछुए की कलम को यह सुनिश्चित करने के लिए चुनती है कि कछुआ चलते समय एक रेखा नहीं खींची जाती है। इसकी गोटो (एक्स, वाई) विधि समन्वय स्थितियों का उपयोग करती है जो कछुए को एक पूर्ण स्थान की ओर ले जाती है।

सांप जो खाने की चीज खाता है, उसे हम बनाते हैं। हम खिलाड़ी के प्रत्येक स्कोर को दिखाना चाहते हैं जब सांप भोजन एकत्र करता है और साथ ही खिलाड़ी पूरे खेल में उच्चतम स्कोर प्राप्त कर सकता है।

यही कारण है कि हम इसे पूरा करने के लिए इस पेन.राइट () प्रक्रिया को नियोजित करते हैं। इस Hideturtle () का उपयोग हेडर क्षेत्र में जहां टेक्स्ट लिखा है, डिस्प्ले से टर्टल आइकन को छिपाने के लिए किया जाता है।

कोड की अंतिम पंक्ति में एक टर्टल.मेनलूप () जोड़ना आवश्यक है जो स्क्रीन को लंबे समय तक दिखाएगा, जिससे उपयोगकर्ता स्क्रीन के साथ बातचीत कर सकेंगे।

सांप को निर्देशित करने के लिए चाबियां सेट करें

यहां, हम विशिष्ट कुंजियां बनाएंगे जो उस दिशा को निर्धारित करती हैं जिस दिशा में सांप को स्क्रीन पर चलना चाहिए। हम “L” अक्षर का उपयोग बाईं कुंजी के रूप में करेंगे, ‘R’ बाईं ओर इंगित करने के लिए,

‘U’ ऊपर की ओर इंगित करने के लिए, और ‘D’ नीचे की ओर इंगित करेगा। निर्देशों को कछुए के दिशा समारोह का उपयोग करके कार्यान्वित किया जाएगा जिसे हम सांप कहते हैं।

# Assigning directions
def moveleft():
    if snake.direction != "right":
        snake.direction = "left"

def moveright():
    if snake.direction != "left":
        snake.direction = "right"

def moveup():
    if snake.direction != "down":
        snake.direction = "up"

def movedown():
    if snake.direction != "up":
        snake.direction = "down"

def move():
    if snake.direction == "up":
        coord_y = snake.ycor()
        snake.sety(coord_y+20)

    if snake.direction == "down":
        coord_y = snake.ycor()
        snake.sety(coord_y-20)

    if snake.direction == "right":
        coord_x = snake.xcor()
        snake.setx(coord_x+20)

    if snake.direction == "left":
        coord_x = snake.xcor()
        snake.setx(coord_x-20)

wind.listen()
wind.onkeypress(moveleft, 'L')
wind.onkeypress(moveright, 'R')
wind.onkeypress(moveup, 'U')
wind.onkeypress(movedown, 'D')

() फ़ंक्शन उपरोक्त चाल सेट करता है () ऊपर वर्णित फ़ंक्शन सांप की दिशा को एक विशिष्ट समन्वय के भीतर निर्दिष्ट स्थिति में अनुमति देता है।

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

सांप के रूप में गेम के गेमप्ले का कार्यान्वयन, हमारे सांपों के खेल के मूलभूत नियमों को निर्धारित करने के बाद हमें खेल को लाइव-एक्शन में बदलने की आवश्यकता होगी।

सांप की लंबाई, इसमें निम्नलिखित शामिल हो सकते हैं:

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

segments = []

#Implementing the gameplay
while True:
    wind.update()
    if snake.xcor() > 290 or snake.xcor() < -290 or snake.ycor() > 290 or snake.ycor() < -290:
        time.sleep(1)
        snake.goto(0, 0)
        snake.direction = "Stop"
        snake.shape("square")
        snake.color("green")

        for segment in segments:
            segment.goto(1000, 1000)
            segments.clear()
            player_score = 0
            delay_time = 0.1
            pen.clear()
            pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), align="center", font=("Arial", 24, "normal"))

        if snake.distance(snake_food) < 20:
            coord_x = random.randint(-270, 270)
            coord_y = random.randint(-270, 270)
            snake_food.goto(coord_x, coord_y)

            # Adding segment
            added_segment = turtle.Turtle()
            added_segment.speed(0)
            added_segment.shape("square")
            added_segment.color("white")
            added_segment.penup()
            segments.append(added_segment)
            delay_time -= 0.001
            player_score += 5

            if player_score > highest_score:
                highest_score = player_score
                pen.clear()
                pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), align="center", font=("Arial", 24, "normal"))

    # checking for collisions
    for i in range(len(segments)-1, 0, -1):
        coord_x = segments[i-1].xcor()
        coord_y = segments[i-1].ycor()
        segments[i].goto(coord_x, coord_y)

    if len(segments) > 0:
        coord_x = snake.xcor()
        coord_y = snake.ycor()
        segments[0].goto(coord_x, coord_y)
    move()

    for segment in segments:
        if segment.distance(snake) < 20:
            time.sleep(1)
            snake.goto(0, 0)
            snake.direction = "stop"
            snake.color('white')
            snake.shape('square')

            for segment in segments:
                segment.goto(1000, 1000)
                segment.clear()
                player_score = 0
                delay_time = 0.1
                pen.clear()
                pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), align="center", font=("Arial", 24, "normal"))

     time.sleep(delay_time)

turtle.mainloop() ऊपर दिए गए कोड स्निपेट में, जिसका हमने उपयोग किया है, हमने स्क्रीन पर साँप के भोजन के लिए एक यादृच्छिक स्थान निर्दिष्ट किया है। जितनी बार सांप भोजन खाता है, शरीर एक अलग रंग में बढ़ता है; इस उदाहरण में सफेद, विकास को चिह्नित करने के लिए।

सांप एक बार खाना इकट्ठा कर लेता है तो उससे नहीं टकराता। भोजन स्क्रीन के आकार के 270 डिग्री समन्वय क्षेत्र के भीतर एक यादृच्छिक स्थान पर प्रदर्शित होता है।

हर बार जब सांप खाना खाता है, तो खिलाड़ी का स्कोर 5 बढ़ जाता है। यदि सांप किसी अन्य खिलाड़ी से टकरा जाता है, तो उनका स्कोर 0 पर रीसेट हो जाता है और स्क्रीन उच्चतम स्कोर के साथ छोड़ दी जाती है। here

Leave a Comment

"
"