Python turtle में पैडल से गेंद की टकराव-दिशा कैसे तय करें

Python turtle मिनी-गेम में पैडल से गेंद के साइड बनाम टॉप टकराव की सटीक पहचान जानें: आस्पेक्ट रेशियो, भारित दूरी और सही vx/vy उलटने की तकनीक.

गेंद पैडल के किनारे से टकराई या ऊपर/नीचे से—यह पता लगाना सुनने में आसान लगता है, पर जब इसे कोड में बाँधते हैं तो बात बदल जाती है। सीमारेखा पर साधारण समानता-जांच तेज़, निरंतर गति में शायद ही उम्मीद के मुताबिक काम करती है। यहाँ Python turtle मिनी-गेम के संदर्भ में समस्या का संक्षिप्त विश्लेषण और टकराव पर इच्छित प्रतिक्रिया दिलाने का साफ-सुथरा तरीका दिया गया है।

समस्या का सेटअप

लक्ष्य यह है कि चलती गेंद पैडल से जहाँ टकराए, उसके अनुसार अलग तरह से उछले। साइड पर हिट होने पर x वेग उलटना चाहिए, जबकि ऊपर या नीचे हिट होने पर y वेग उलटना चाहिए।

from turtle import Turtle, Screen
import time
import random
# --------------- वैश्विक चर --------------------
vx = 20
vy = 20
tiles = []
def detect_hit():
    global vx, vy, tiles
    if orb.xcor() > (canvas.window_width() / 2) - 20 or orb.xcor() < -(canvas.window_width() / 2) + 20:
        vx *= -1
    elif orb.ycor() > (canvas.window_height() / 2) - 20 or orb.ycor() < -(canvas.window_height() / 2) + 20:
        vy *= -1
    elif abs(bar.xcor() - orb.xcor()) < 20/2 + 150/2 and abs(bar.ycor() - orb.ycor()) < 20/2 + 60/2:
        if abs(bar.xcor() - orb.xcor()) == 20/2 + 150/2:
            vx *= -1
        else:
            vy *= -1
def tick():
    orb.goto(orb.xcor() + vx, orb.ycor() + vy)
    detect_hit()
    canvas.update()
    canvas.ontimer(tick, 1)
def nudge_right():
    bar.setx(bar.xcor() + 25)
def nudge_left():
    bar.setx(bar.xcor() - 25)
canvas = Screen()
time.sleep(2)
orb = Turtle(shape='circle')
orb.pu()
orb.speed(0)
orb.goto(0, -300)
orb.speed(0)
orb.left(random.randint(45, 135))
bar = Turtle(shape='square')
bar.speed(0)
bar.goto(0, -400)
bar.shapesize(1, 7.5, 3)
bar.up()
canvas.listen()
canvas.onkeypress(nudge_right, 'Right')
canvas.onkeypress(nudge_left, 'Left')
canvas.onkeypress(nudge_right, 'd')
canvas.onkeypress(nudge_left, 'a')
tick()
canvas.mainloop()

मूल तरीका हिट्स को गलत वर्गीकृत क्यों करता है

ऊपर दिया गया साइड बनाम टॉप फैसला इस पर टिका है कि क्षैतिज दूरी किसी निश्चित सीमा-योग के बराबर है या नहीं। गतिशील स्थिति में यह समानता-जांच इस बात का भरोसेमंद संकेत नहीं देती कि किस सतह से संपर्क हुआ, खासकर जब पैडल एक आयाम में दूसरे की तुलना में कहीं लंबा हो। यहाँ पैडल 1 से 7.5 के अनुपात में फैला हुआ है, इसलिए बिना स्केल किए दूरी की साधारण तुलना उसके आकार को नहीं दर्शाती।

असल मदद यह करती है कि पैडल के अनुपात के सापेक्ष, गेंद का प्रत्येक धुरी पर कितना विस्थापन है—इसकी तुलना की जाए। यदि टकराव सचमुच ऊपर या नीचे है, तो ऊर्ध्वाधर विस्थापन प्रमुख होगा; साइड पर होने पर क्षैतिज विस्थापन हावी रहेगा। इस तुलना में पैडल के आस्पेक्ट रेशियो को शामिल करना ही कुंजी है।

भारित धुरी-दूरी के साथ भरोसेमंद साइड बनाम टॉप जाँच

व्यावहारिक नियम सीधा है। पैडल के स्ट्रेच के अनुसार x और y की निरपेक्ष दूरी को स्केल करके आपस में तुलना करें। यदि स्केल की गई x दूरी बड़ी हो, तो इसे साइड हिट मानकर x वेग उलटें; अन्यथा इसे टॉप/बॉटम हिट मानकर y वेग उलटें। इस निर्णय में पैडल के 1:7.5 अनुपात का सीधा इस्तेमाल होता है।

if abs(bar.xcor() - orb.xcor()) * 1 > abs(bar.ycor() - orb.ycor()) * 7.5:
    vx *= -1
else:
    vy *= -1

दूसरे शब्दों में, टॉप या बॉटम टकराव ठहरने के लिए y दूरी का अनुपातिक रूप से अधिक होना ज़रूरी है। चूँकि पैडल क्षैतिज दिशा में काफी लंबा है, इसलिए तुलनीयता के लिए y दूरी को 7.5 से भारित करना पड़ता है।

संदर्भ में सुधरा हुआ टकराव-विकल्प

यह अनुपातिक तुलना टकराव वाले हिस्से में जोड़ें और बाकी सब वैसा ही रहने दें। ओवरलैप की जाँच पहले जैसी ही रहे; फर्क सिर्फ इतना है कि ओवरलैप मिलते ही कौन-सी धुरी उलटनी है—यह अब नई तुलना तय करेगी।

def detect_hit():
    global vx, vy, tiles
    if orb.xcor() > (canvas.window_width() / 2) - 20 or orb.xcor() < -(canvas.window_width() / 2) + 20:
        vx *= -1
    elif orb.ycor() > (canvas.window_height() / 2) - 20 or orb.ycor() < -(canvas.window_height() / 2) + 20:
        vy *= -1
    elif abs(bar.xcor() - orb.xcor()) < 20/2 + 150/2 and abs(bar.ycor() - orb.ycor()) < 20/2 + 60/2:
        if abs(bar.xcor()) or abs(orb.xcor()):  # प्लेसहोल्डर: यह दिखाने के लिए कि केवल निर्णय-तर्क बदला है
            pass
        # भारित दूरियों की तुलना करके कौन-सी धुरी पलटनी है, यह तय करें
        if abs(bar.xcor() - orb.xcor()) * 1 > abs(bar.ycor() - orb.ycor()) * 7.5:
            vx *= -1
        else:
            vy *= -1

सार यही अनुपातिक तुलना है। यहाँ 1 और 7.5 के भार पैडल के स्ट्रेच कारकों से मेल खाते हैं; पैडल का आकार बदलने पर इन्हें बदला जा सकता है।

यह क्यों मायने रखता है

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

समापन और व्यावहारिक सलाह

संपर्क पहचानने के लिए ओवरलैप जाँचें, फिर पैडल के आस्पेक्ट रेशियो के हिसाब से स्केल की गई x और y की निरपेक्ष दूरियों की तुलना करके प्रतिबिंबित होने वाली धुरी तय करें। इससे तर्क संक्षिप्त रहता है और स्क्रीन पर दिख रहे वास्तविक आकार के अनुरूप रहता है। आगे चलकर अगर पैडल का स्ट्रेच बदलें, तो वही व्यवहार बनाए रखने के लिए भारों को भी उसी अनुसार अपडेट करें। साथ ही, इनपुट हैंडलिंग और टाइमर की लय पर नज़र रखें: सीधे की-ट्रिगर और बहुत आक्रामक टाइमर गति को झटकों वाला बना सकते हैं; ऐसा कैडेंस सेट करें जिसे CPU आराम से संभाल सके, इससे गेमप्ले अधिक स्मूद होता है।