उदाहरण: पूर्ण खेल

यह पाठ एक छोटे संग्रह खेल का निर्माण करता है। खिलाड़ी एक दृश्य के चारों ओर चलता है, दीवारों से टकराता है, सिक्के इकट्ठा करता है, और खेल समाप्त होने पर अंतिम स्कोर प्रिंट करता है।

पूरे स्क्रिप्ट को एक साथ पेस्ट करने के बजाय, उदाहरण को उन भागों में विभाजित किया गया है जो आप अधिकांश Tiniest2D परियोजनाओं में उपयोग करेंगे:

संपत्ति और राज्य चर
start()
onUpdate(dt)
onCollision(objA, objB)
end()

1. संपत्तियां और खेल राज्य

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

// संपत्तियां बनाना
var playerImg = Sprite(16, 16)
var wallImg = Sprite(16, 16)
var coinImg = Sprite(8, 8)
var level = Scene()

// खिलाड़ी ऑब्जेक्ट बनाना
var player = Object("Player")

// खेल राज्य
var score = 0
var speed = 100

इस बिंदु पर, चर मौजूद हैं, लेकिन खेल ने अभी तक दृश्य में कुछ नहीं रखा है। वह सेटअप start() में होता है।

2. start() फ़ंक्शन

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

func start() {
    // खिलाड़ी की सेटअप
    setSprite(player, playerImg)
    setCollisionType(player, COLLISION_DYNAMIC())
    setX(player, 50)
    setY(player, 50)
    addObject(level, player)

    // प्रारंभिक दृश्य सेट करना
    setScene(level)

    // कैमरा को खिलाड़ी पर केंद्रित करें
    setCameraX(level, getX(player))
    setCameraY(level, getY(player))
    setCameraZoom(level, 3)

    print("सिक्के इकट्ठा करें!")
}

खिलाड़ी COLLISION_DYNAMIC() का उपयोग करता है क्योंकि इसे टकराना चाहिए और दीवारों से बाहर धकेलना चाहिए। कैमरा खिलाड़ी के चारों ओर केंद्रित है ताकि स्तर का दृश्य सही स्थान पर शुरू हो।

3. onUpdate(dt) फ़ंक्शन

onUpdate(dt) प्रत्येक फ्रेम में चलता है। यह वह स्थान है जहां खिलाड़ी इनपुट पढ़ता है, चलता है, कैमरे को अपडेट करता है, और रीसेट कुंजियों की जांच करता है।

dt का अर्थ है "डेल्टा समय": पिछले फ्रेम से बिताया गया समय। गति को dt से गुणा करने से विभिन्न फ्रेम दरों के बीच गति की गति अधिक स्थिर होती है।

func onUpdate(dt) {
    // खिलाड़ी का आंदोलन
    var moveX = 0
    var moveY = 0

    if (isKeyHeld(KEY_LEFT()) || isKeyHeld(KEY_A())) {
        moveX = -1
    }
    if (isKeyHeld(KEY_RIGHT()) || isKeyHeld(KEY_D())) {
        moveX = 1
    }
    if (isKeyHeld(KEY_UP()) || isKeyHeld(KEY_W())) {
        moveY = -1
    }
    if (isKeyHeld(KEY_DOWN()) || isKeyHeld(KEY_S())) {
        moveY = 1
    }

    // आंदोलन लागू करना
    setX(player, getX(player) + moveX * speed * dt)
    setY(player, getY(player) + moveY * speed * dt)

    // कैमरा खिलाड़ी का अनुसरण करता है
    setCameraX(level, getX(player))
    setCameraY(level, getY(player))

    // R कुंजी से स्तर रीसेट करें
    if (isKeyPressed(KEY_R())) {
        resetScene(level)
        setX(player, 50)
        setY(player, 50)
        score = 0
        print("स्तर रीसेट!"
    }
}

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

4. onCollision(objA, objB) फ़ंक्शन

onCollision(objA, objB) तब चलाता है जब दो वस्तुएं टकराती हैं। इस उदाहरण में, सिक्कों को COLLISION_TRIGGER() का उपयोग करना चाहिए। ट्रिगर ऑब्जेक्ट ओवरलैप को रिपोर्ट करते हैं, लेकिन वे गति को ब्लॉक नहीं करते हैं।

func onCollision(objA, objB) {
    var nameB = getName(objB)
    var typeB = getCollisionType(objB)

    // सिक्का संग्रह (सिक्कों को दृश्य संपादक में ट्रिगर प्रकार होना चाहिए)
    if (typeB == COLLISION_TRIGGER()) {
        removeObject(level, objB)
        score = score + 1
        print("स्कोर: " + score)
    }
}

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

5. end() फ़ंक्शन

end() तब चलता है जब खेल रुकता है। इस उदाहरण में केवल अंतिम स्कोर प्रिंट होता है, लेकिन बड़े खेल इस फ़ंक्शन का उपयोग सफाई या अंतिम डिबग संदेशों के लिए कर सकते हैं।

func end() {
    print("अंतिम स्कोर: " + score)
}

उदाहरण सेट करना

स्प्राइट बनाना:
playerImg पर Ctrl+Click करें, एक चरित्र (उदाहरण के लिए, एक साधारण स्टिक फिगर) बनाएं
wallImg पर Ctrl+Click करें, एक ठोस ब्लॉक बनाएं
coinImg पर Ctrl+Click करें, एक छोटा गोला या हीरा बनाएं
दृश्य डिजाइन करें:
level पर Ctrl+Click करें
बाएं पैनल में wallImg का चयन करें, टकराव को "स्थिर" सेट करें
दीवारों को किनारों के चारों ओर पेंट करें और एक भूलभुलैया बनाएं
coinImg का चयन करें, सजावटी सिक्का टाइलों के लिए टकराव को "कोई नहीं" सेट करें
स्तर के चारों ओर सिक्के रखें जैसे दृश्य मार्गदर्शक
ट्रिगर सिक्का ऑब्जेक्ट बनाएं:

दृश्य में स्टैम्पेड स्प्राइट tiles और सजावट के लिए उपयोगी होते हैं, लेकिन संग्रहणीय सिक्के ऑब्जेक्ट होने चाहिए ताकि टकराव कॉलबैक उन्हें हटा सके। सिक्का ऑब्जेक्ट्स इस तरह जोड़ें:

var coin1 = Object("Coin1")
var coin2 = Object("Coin2")

func start() {
    // ... खिलाड़ी सेटअप ...

    // ट्रिगर के रूप में सिक्कों की सेटअप
    setSprite(coin1, coinImg)
    setCollisionType(coin1, COLLISION_TRIGGER())
    setX(coin1, 100)
    setY(coin1, 80)
    addObject(level, coin1)

    setSprite(coin2, coinImg)
    setCollisionType(coin2, COLLISION_TRIGGER())
    setX(coin2, 150)
    setY(coin2, 120)
    addObject(level, coin2)

    // ... बाकी सेटअप ...
}

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

Tiniest2D के साथ 2D गेम बनाएं

पूर्ण खेल उदाहरण

Keep your place in this quest