Snake Game သည် Python Module ပရိုဂရမ်ကို အသုံးပြု၍ Code အလုပ်ဖြစ်သည်။

Python Module ကို အသုံးပြု၍ Snake Game

သင်သည် မြွေဂိမ်းကို နှစ်သက်သူဖြစ်ပါက ဤစာစီစာကုံးသည် သင့်အတွက် အထောက်အကူဖြစ်မည်ဟု ယုံကြည်ပါသည်။. Python newbies တွေတောင် အလွယ်တကူ ဖန်တီးနိုင်စေမယ့် ရိုးရှင်းတဲ့ ဂိမ်းတစ်ခု ဖန်တီးပုံအဆင့်ဆင့်ကို ဒီပို့စ်မှာ ဖော်ပြပေးလိုက်ပါတယ်. Python ရှိ PyGame စာကြည့်တိုက်, ၎င်းသည် ဂိမ်းများကို ဖန်တီးရန်အတွက် ကျွန်ုပ်တို့အသုံးပြုသည့် Python ပက်ကေ့ဂျ်ဖြစ်သည်။, ဂိမ်းကို ဒီဇိုင်းဆွဲရန် အမျိုးမျိုးသော နည်းလမ်းများထဲမှ တစ်ခုဖြစ်သည်။.

စာကြည့်တိုက်လိပ်အသုံးပြုခြင်းသည် နောက်ထပ်နည်းဗျူဟာတစ်ခုဖြစ်သည်။. အသုံးပြုသူများသည် ဤ module ကြောင့် ဂရပ်ဖစ်များကို ဖန်တီးနိုင်ပြီး အွန်လိုင်း ကင်းဗတ်တွင် ပုံစံများကို ရေးဆွဲနိုင်သည်။, ၎င်းသည် Python ဖြင့်ထည့်သွင်းပြီးဖြစ်သည်။. ဒီတော့, ဤသင်ခန်းစာတွင်, ကျွန်ုပ်တို့၏အခြေခံမြွေကိုတည်ဆောက်ရန် လိပ်စာကြည့်တိုက်ကို အသုံးပြုပါမည်။

• အချိန် module. ဤနည်းပညာသည် ကျွန်ုပ်တို့အား ယခင်အချိန်ကတည်းက ကျော်လွန်သွားခဲ့သော စက္ကန့်ပမာဏကို ခြေရာခံနိုင်စေပါသည်။.
• မြွေဂိမ်း Random module – ၎င်းသည် Python တွင် ကျပန်းနံပါတ်များကို ဖန်တီးပေးသည်။.

သင်လိုအပ်မည့် အခြားသော ကိရိယာများတွင် သင်နှစ်သက်သည့် စာသားအတွက် တည်းဖြတ်သူ ပါဝင်သည်။. ဒီ post မှာ VSCode ကိုသုံးပါမယ်။. ဒါပေါ့, Python ကို စနစ်ထည့်သွင်းရန် သင်လိုအပ်ပါသည်။ 3 မတပ်ဆင်ရသေးပါက သင့်စက်ပေါ်တွင်. Geekflare Compiler ကို ထည့်သွင်းရန်လည်း ဒေါင်းလုဒ်လုပ်နိုင်ပါသည်။. ဒါက ပျော်စရာကောင်းတဲ့ အတွေ့အကြုံတစ်ခု ဖြစ်နိုင်တယ်။!

မြွေဂိမ်းဘယ်လိုအလုပ်လုပ်သလဲ။

ကစားသမားများသည် ဤဂိမ်းတွင် ဖြစ်နိုင်ချေအကောင်းဆုံးရမှတ်များရရှိရန် စခရင်ပေါ်တွင်ပြသထားသည့် အစာကိုရယူရန် မြွေကို ကိုင်တွယ်ရပါမည်. ကစားသမားသည် မြွေရွေ့လျားနေသည့် ဦးတည်ရာကိုညွှန်ပြသည့် လမ်းကြောင်းခလုတ်လေးခုအနက်မှ တစ်ခုကို နှိပ်ခြင်းဖြင့် မြွေကို ညွှန်ပြသည်။.

ကစားသမား သို့မဟုတ် အရာဝတ္ထုကို ထိမိပါက မြွေကို ဂိမ်းမှ ဖယ်ရှားပါမည်။. ဤဂိမ်းကို ရှေ့ဆက်ကစားရန် ကျွန်ုပ်တို့အသုံးပြုမည့် နည်းလမ်းများ.

• ကြိုတင်ထည့်သွင်းထားသည့် module များကို ကျွန်ုပ်တို့၏ အပလီကေးရှင်းများထဲသို့ တင်သွင်းခြင်း။ (လိပ်အချိန်, လိပ်လည်း ကြုံသလို).
• ဂိမ်း၏မျက်နှာပြင်ပြသမှုကို Turtle module ဖြင့်ဖန်တီးထားသည်။.
• စခရင်တဝိုက်တွင် မြွေ၏ရွေ့လျားမှုလမ်းကြောင်းကို ထိန်းချုပ်ရန် သော့များကို သတ်မှတ်ပါ။.
• ဂိမ်း၏အကောင်အထည်ဖော်မှု.

အကောင်အထည်ဖော်မှုပရိုဂရမ်ကို ထည့်သွင်းမည့်မြွေဂိမ်း.py ဖိုင်ကို ဖန်တီးပါ။.

မော်ဂျူးများကို တင်သွင်းခြင်း။

ပရိုဂရမ်၏ ဤအပိုင်းသည် Python-installed time ကို load လုပ်သည်။, လိပ်, နှင့် ကျပန်း module များ. ထို့အပြင်, ကစားသမား၏ ကနဦးရမှတ်အတွက် မူရင်းနံပါတ်များ, သူတို့ တက်နိုင်တဲ့ အမြင့်ဆုံးရမှတ်, ရွေ့လျားမှုတစ်ခုစီကြားတွင် ကစားသမားနှောင့်နှေးသည့်အချိန်ပမာဏကို သတ်မှတ်ပေးမည်ဖြစ်သည်။. အချိန်မည်မျှနောက်ကျခဲ့သည်ကို သိရှိနိုင်ရန်, အချိန် module လိုအပ်သည်။.

import turtle
import random
import time

player_score = 0
highest_score = 0
delay_time = 0.1

ဂိမ်း၏မျက်နှာပြင်ကိုပြုလုပ်ခြင်း။

ကျွန်ုပ်တို့ထည့်သွင်းသော လိပ်မော်ဂျူးသည် ဂိမ်း၏ဝင်းဒိုးစခရင်အဖြစ် အသုံးပြုမည့် virtual 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()

အထက်ဖော်ပြပါ ကောက်နုတ်ချက်ရှိ ကုဒ်သည် ကနဦးခေါင်းစဉ်နှင့် နောက်ခံအရောင်ကို မထည့်မီ လိပ်စခရင်ကို ဦးစွာ သတ်မှတ်ပေးသည်. ကျွန်ုပ်တို့၏ဒစ်ဂျစ်တယ်ပတ္တူပေါ်၌ မြွေ၏ပုံသဏ္ဍာန်ကို မရေးဆွဲမီ အရွယ်အစားကို ဦးစွာရွေးချယ်ပါ။. လိပ်ရွေ့လျားနေစဉ် မျဉ်းကြောင်းများမဖြစ်အောင်၊, penup method သည် လိပ်ဘောပင်ကို ကောက်ယူသည်။.

၎င်း၏ Goto နည်းပညာကို အသုံးပြု, လိပ်ကို သြဒိနိတ်များသုံးပြီး အတိအကျ အနေအထားသို့ ညွှန်ကြားနိုင်သည်။. မြွေစားတဲ့ အစာကို ငါတို့လုပ်တယ်။.

မြွေက အစာစုတဲ့အချိန်တိုင်း, ကစားသမားတစ်ဦးစီရဲ့ ရမှတ်တွေကို ပြသချင်ပါတယ်။. ကျွန်ုပ်တို့သည် ဂိမ်းအတွင်း လူတစ်ဦးရရှိသော အမြင့်ဆုံးရမှတ်ကိုလည်း ပြသလိုပါသည်။. ဒီအတွက်ကြောင့်, ဖောင်တိန်သုံးတယ်။. ဘောပင်အဖြစ်, ရေးပါ။. ပြီးမြောက်ရန် နည်းလမ်းကို ဖော်ပြပါ။.

မြွေအတွက်လမ်းညွှန်သော့များတပ်ဆင်ခြင်း။

ဤဥပမာတွင်, မျက်နှာပြင်တစ်လျှောက် မြွေ၏ရွေ့လျားမှုကို ထိန်းချုပ်ရန်အတွက် အချို့သောသော့များကို ကျွန်ုပ်တို့ အစီအစဉ်ချပါသည်။. ငါတို့က စာကိုသုံးမယ်။ “ဌ” ဘယ်ဘက်သော့အဖြစ်, “R” လက်ဝဲ, “ဦး” အထက်သို့, နှင့် “ဃ” အောက်သို့. ဤညွှန်ကြားချက်များကို လိပ်၏လမ်းညွှန်မှုလုပ်ဆောင်ချက်ကို အသုံးပြု၍ မြွေကိုခေါ်ခြင်းဖြင့် လက်တွေ့လုပ်ဆောင်မည်ဖြစ်သည်။.

သင့်တွင် အောက်ပါ ကုဒ်နမူနာများကို ထည့်သွင်းပါ။.

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

ရွှေ့ပါ။() အထက်ဖော်ပြပါလုပ်ဆောင်ချက်သည် သတ်မှတ်ထားသော သြဒီနိတ်အတွင်း သတ်မှတ်ထားသည့် အနေအထားတွင် မြွေ၏လှုပ်ရှားမှုကို ခွင့်ပြုသည်။. နားထောင်ပါ။() အသုံးပြုသူသည် ခလုတ်ကိုနှိပ်လိုက်သည်နှင့် မြွေကို ညွှန်ကြားသည့်နည်းလမ်းများကို ခေါ်ဆိုသည့် event နားဆင်သူအဖြစ် လုပ်ဆောင်သည်။.

မြွေပုံစံဖြင့် ဂိမ်း၏ကစားနည်းကို အကောင်အထည်ဖော်ခြင်း။

အခြေခံဖွဲ့စည်းပုံတည်ဆောက်ပြီးပါက ဂိမ်းကို တိုက်ရိုက်လုပ်ဆောင်ချက်အဖြစ် ပြောင်းလဲရန် လိုအပ်ပါသည်။. ဒါက ပါဝင်ပါလိမ့်မယ်။:

• အစာစားတိုင်း မြွေ၏အရှည်ကို မတူညီသောအရောင်ဖြင့် ချဲ့ပါ။.
• မြွေသည် အစာစားသောအခါတိုင်း၊, ကစားသမား၏ရမှတ်သည်တိုးလာသည်။, ထို့နောက် အမြင့်ဆုံးရမှတ်ကို ခြေရာခံသည်။.
• မြွေသည် နံရံနှင့် ၎င်း၏ကိုယ်ကိုပင် ထိမိခြင်းမှ ကာကွယ်ရန် ထိန်းထားနိုင်သည်။.
• ပြီးရင် မြွေကို ရိုက်တယ်။, ဂိမ်းကိုဆက်လက်.
• ဒါပေမယ့် screen ပေါ်မှာ, ဂိမ်းပြန်လည်စတင်ချိန်တွင် ကစားသမား၏ရမှတ်သည် သုညသို့ ပြန်လည်သတ်မှတ်ထားသော်လည်း ကစားသမား၏ရမှတ်သည် အမြင့်ဆုံးဖြစ်သည်။.

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 မျက်နှာပြင်သည် ၎င်း၏အမြင့်ဆုံးရမှတ်ကို ထိန်းသိမ်းထားသည်။.

ကောက်ချက်

လိပ်စာကြည့်တိုက်သည် ဤကျူတိုရီရယ်တွင် ကျွန်ုပ်တို့မြင်ခဲ့ရသည့် မြွေဂိမ်းကို ဖန်တီးရန် ပျော်စရာနှင့် ရိုးရှင်းသောနည်းလမ်းတစ်ခုဖြစ်သည်။. တူညီသောဂိမ်းကိုအကောင်အထည်ဖော်ရန် Python ရှိ PyGame စာကြည့်တိုက်ကိုလည်း သင်အသုံးပြုနိုင်ပါသည်။. ဒါတွေကိုဖတ်ခြင်းအားဖြင့် ဂိမ်းကို ကွဲပြားစွာအသုံးချနိုင်ပုံကို ရှာဖွေပါ။ PyGame ညွှန်ကြားချက်များ.

Snake Rivals ပျော်စရာ Snake ဂိမ်းကို ဒေါင်းလုဒ်လုပ်ပါ။

Snake Run Race 3D အပြေးဂိမ်း

Snake.io - ပျော်စရာ Snake .io ဂိမ်းများကို ဒေါင်းလုဒ်လုပ်ပါ။