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

टकराव प्रणाली

यह कैसे काम करता है

• हर ऑब्जेक्ट का एक आयताकार कोलाइडर होता है जो इसके स्प्राइट के आकार पर आधारित होता है
• स्प्राइट कस्टम कोलाइडर सीमाएँ हो सकती हैं (स्प्राइट संपादक में सेट की जाती हैं)
• ऑब्जेक्ट का घुमाव कोलाइडर को ऑब्जेक्ट के केंद्र ऑफसेट के चारों ओर घुमाता है
• टकराव SAT (Separating Axis Theorem) का उपयोग करता है, इसलिए घुमाए गए आयत वास्तविक घुमाए गए आकार के साथ टकराते हैं
• गतिशील ऑब्जेक्ट्स के लिए हर फ्रेम पर टकराव की जांच की जाती है

टकराव के प्रकार समझाए गए

1. कोई नहीं - ऑब्जेक्ट को टकराव प्रणाली द्वारा पूरी तरह नज़रअंदाज़ किया जाता है
2. स्थिर - एक अविचल दीवार के रूप में कार्य करता है (भूमि, प्लेटफार्मों के लिए उपयोग करें)
3. गतिशील - अन्य कोलाइडरों से बाहर धकेला जाता है (खिलाड़ी, दुश्मनों के लिए उपयोग करें)
4. ट्रिगर - ओवरलैप का पता लगाता है लेकिन गति को अवरोधित नहीं करता (एकत्र करने योग्य वस्तुओं, क्षेत्रों के लिए उपयोग करें)

टकराव समाधान

• गतिशील ऑब्जेक्ट्स स्वचालित रूप से स्थिर और अन्य गतिशील ऑब्जेक्ट्स से बाहर धकेले जाते हैं
• ट्रिगर कभी भी गति को अवरोधित नहीं करते - वे केवल ओवरलैप का पता लगाते हैं
• घुमाए गए कोलाइडर सबसे छोटे ओवरलैप दिशा के साथ हल किए जाते हैं

onCollision कॉलबैक

onCollision(objA, objB) फ़ंक्शन तब कॉल होता है जब ऑब्जेक्ट्स ओवरलैप होते हैं। कॉलबैक पैटर्न हैं:

मुख्य नियम:

• objA हमेशा या तो गतिशील या ट्रिगर होता है
• जब दो गतिशील ऑब्जेक्ट्स टकराते हैं, तो दोनों को एक कॉलबैक मिलता है (प्रत्येक को objA के रूप में)
• जब दो ट्रिगर्स ओवरलैप करते हैं, तो एक कॉलबैक उत्पन्न होता है (पहला ट्रिगर objA के रूप में)
• स्थिर ऑब्जेक्ट्स कभी objA के रूप में नहीं दिखाई देते

उदाहरण: विभिन्न टकराव प्रकारों का पता लगाना

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

    // खिलाड़ी (गतिशील) एक सिक्के (ट्रिगर) को छू रहा है
    if (getName(objA) == "player" && typeB == COLLISION_TRIGGER()) {
        print("एकत्रित किया!")
        removeObject(gameScene, objB)
    }

    // दो ट्रिगर्स ओवरलैप (जैसे, डिटेक्शन ज़ोन)
    if (typeA == COLLISION_TRIGGER() && typeB == COLLISION_TRIGGER()) {
        print(getName(objA) + " ने " + getName(objB) + " के क्षेत्र में प्रवेश किया")
    }

    // खिलाड़ी को दुश्मन द्वारा हिट किया गया (दोनों गतिशील)
    if (getName(objA) == "player" && getName(objB) == "enemy") {
        print("खिलाड़ी हिट हुआ!")
    }
}

भौतिकी प्रणाली

Tiniest Engine में एक अंतर्निहित भौतिकी प्रणाली है जो गतिशील ऑब्जेक्ट्स के लिए स्वचालित रूप से गुरुत्वाकर्षण और वेग को संभालती है।

भौतिकी कैसे काम करती है

हर फ्रेम में, इंजन स्वचालित रूप से:

1. प्रत्येक गतिशील ऑब्जेक्ट की गति पर दृश्य गुरुत्वाकर्षण लागू करता है
2. प्रत्येक गतिशील ऑब्जेक्ट की स्थिति पर गति लागू करता है

// भौतिकी पाइपलाइन (स्वचालित रूप से इंजन द्वारा संभाली गई):
velocity += gravity * dt
position += velocity * dt

गुरुत्वाकर्षण सेट करना

गतिशील ऑब्जेक्ट्स को गिराने के लिए दृश्य पर गुरुत्वाकर्षण सेट करें:

func start() {
    // नीचे की ओर गुरुत्वाकर्षण सेट करें (300 पिक्सल प्रति सेकंड वर्ग)
    setGravityY(gameScene, 300)

    // वैकल्पिक: क्षैतिज गुरुत्वाकर्षण (हवा का प्रभाव)
    setGravityX(gameScene, 0)

    setScene(gameScene)
}

वेग का उपयोग करना

स्थान को सीधे सेट करने के बजाय वेग का उपयोग करके ऑब्जेक्ट्स को नियंत्रित करें:

var player = Object("player")
var jumpForce = -200  // नकारात्मक = ऊपर की ओर

func start() {
    setCollisionType(player, COLLISION_DYNAMIC())
    addObject(gameScene, player)
    setGravityY(gameScene, 300)
    setScene(gameScene)
}

func onUpdate(dt) {
    // वेग के माध्यम से क्षैतिज आंदोलन
    if (isKeyHeld(KEY_LEFT())) {
        setVelocityX(player, -100)
    } else if (isKeyHeld(KEY_RIGHT())) {
        setVelocityX(player, 100)
    } else {
        setVelocityX(player, 0)
    }

    // ऊपर की ओर वेग सेट करके कूदें
    if (isKeyPressed(KEY_SPACE())) {
        setVelocityY(player, jumpForce)
    }
}

भौतिकी फ़ंक्शंस

महत्वपूर्ण: केवल COLLISION_DYNAMIC() ऑब्जेक्ट्स गुरुत्वाकर्षण द्वारा प्रभावित होते हैं और उनकी वेग स्वचालित रूप से लागू की जाती है