MatterJS के साथ अन्य निकायों के माध्यम से बल-खींचने वाले निकायों को रोकें


14

मैं भौतिक विज्ञान आधारित खेल के लिए MatterJs का उपयोग कर रहा हूं और अन्य निकायों के माध्यम से माउस द्वारा निकाले जाने वाले निकायों को रोकने की समस्या का हल नहीं मिला है। यदि आप एक शरीर को दूसरे शरीर में खींचते हैं, तो खींचा जा रहा शरीर खुद को दूसरे शरीर में और उसके माध्यम से मजबूर कर सकता है। मैं उन्हें रोकने के लिए एक विश्वसनीय तरीके की तलाश कर रहा हूं। आप माउस के साथ एक शरीर का चयन करके किसी भी MatterJS डेमो में इस आशय का निरीक्षण कर सकते हैं, और दूसरे शरीर के माध्यम से इसे लागू करने की कोशिश कर सकते हैं। यहाँ एक विशिष्ट उदाहरण है:

यहां छवि विवरण दर्ज करें

https://brm.io/matter-js/demo/#staticFriction

दुर्भाग्य से यह ड्रैग-एंड-ड्रॉप के आधार पर किसी भी गेम या सिमुलेशन को तोड़ता है। मैंने कई समाधानों का प्रयास किया है, जैसे कि टक्कर होने पर माउस की बाधा को तोड़ना, या बाधा की कठोरता को कम करना, लेकिन ऐसा कुछ भी नहीं जो मज़बूती से काम करता हो।

किसी भी सुझाव का स्वागत है!


मैं बल-घसीटे हुए शब्द को नहीं समझता। क्या आपका मतलब है कि आपका खींचा हुआ शरीर किसी अन्य शरीर के माध्यम से जाना चाहिए?
गरोडज़ी

नहीं, इसका मतलब है कि खींचे गए शरीर को किसी अन्य शरीर के माध्यम से जाने से रोका जाना चाहिए।
d13

1
@ d13 क्या आप इस मुद्दे को दर्शाने वाला एनीमेशन जोड़ सकते हैं? चूँकि शब्दांकन के आधार पर कुछ भ्रम प्रतीत होता है ...
घोस्ट

2
@ गोस्ट ने जोड़ा ...
d13

@ d13 जो चीजों को स्पष्ट करता है ..... यह एक मुश्किल है
घोस्ट

जवाबों:


6

मुझे लगता है कि Matter.Resolverकिसी भी निकाय के बीच भौतिक टकराव की भविष्यवाणिय परिहार को लागू करने के लिए यहां सबसे अच्छा उत्तर मॉड्यूल के लिए एक महत्वपूर्ण ओवरहाल होगा । कुछ भी छोटा होना निश्चित परिस्थितियों में विफल होने की गारंटी है। कहा जा रहा है कि यहां दो "समाधान" हैं, जो वास्तव में, केवल आंशिक समाधान हैं। वे नीचे उल्लिखित हैं।


समाधान 1 (अपडेट)

इस समाधान के कई फायदे हैं:

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

इस दृष्टिकोण के पीछे का विचार यह होता है कि "क्या होता है" जब एक अजेय बल एक स्थिर वस्तु से मिलता है तो "विरोध को रोकने के लिए" बल को रोक कर। इसके द्वारा सक्षम किया गया है Matter.Event beforeUpdate, जो positionImpulseप्रत्येक दिशा में उपयोगकर्ता द्वारा परिभाषित सीमा के लिए विवश होने के लिए पूर्ण वेग और आवेग (या जो वास्तव में भौतिक आवेग नहीं है) की अनुमति देता है।

window.addEventListener('load', function() {
    var canvas = document.getElementById('world')
    var mouseNull = document.getElementById('mouseNull')
    var engine = Matter.Engine.create();
    var world = engine.world;
    var render = Matter.Render.create({    element: document.body, canvas: canvas,
                 engine: engine, options: { width: 800, height: 800,
                     background: 'transparent',showVelocity: true }});
    var body = Matter.Bodies.rectangle(400, 500, 200, 60, { isStatic: true}), 
        size = 50, counter = -1;
     
    var stack = Matter.Composites.stack(350, 470 - 6 * size, 1, 6, 
                                        0, 0, function(x, y) {
     return Matter.Bodies.rectangle(x, y, size * 2, size, {
         slop: 0, friction: 1,    frictionStatic: Infinity });
    });
    Matter.World.add(world, [ body, stack,
     Matter.Bodies.rectangle(400, 0, 800, 50, { isStatic: true }),
     Matter.Bodies.rectangle(400, 600, 800, 50, { isStatic: true }),
     Matter.Bodies.rectangle(800, 300, 50, 600, { isStatic: true }),
     Matter.Bodies.rectangle(0, 300, 50, 600, { isStatic: true })
    ]);

    Matter.Events.on(engine, 'beforeUpdate', function(event) {
     counter += 0.014;
     if (counter < 0) { return; }
     var px = 400 + 100 * Math.sin(counter);
     Matter.Body.setVelocity(body, { x: px - body.position.x, y: 0 });
     Matter.Body.setPosition(body, { x: px, y: body.position.y });
     if (dragBody != null) {
        if (dragBody.velocity.x > 25.0) {
            Matter.Body.setVelocity(dragBody, {x: 25, y: dragBody.velocity.y });
        }
        if (dragBody.velocity.y > 25.0) {
            Matter.Body.setVelocity(dragBody, {x: dragBody.velocity.x, y: 25 });
        }
        if (dragBody.positionImpulse.x > 25.0) {
            dragBody.positionImpulse.x = 25.0;
        }
        if (dragBody.positionImpulse.y > 25.0) {
            dragBody.positionImpulse.y = 25.0;
        }
    }
    });

    var mouse = Matter.Mouse.create(render.canvas),
     mouseConstraint = Matter.MouseConstraint.create(engine, { mouse: mouse,
         constraint: { stiffness: 0.1, render: { visible: false }}});
     
    var dragBody = null


    Matter.Events.on(mouseConstraint, 'startdrag', function(event) {
     dragBody = event.body;
    });
    
    Matter.World.add(world, mouseConstraint);
    render.mouse = mouse;
    Matter.Engine.run(engine);
    Matter.Render.run(render);
});
<canvas id="world"></canvas>
<script src="https://cdnjs.cloudflare.com/ajax/libs/matter-js/0.10.0/matter.js"></script>

उदाहरण में, मैं velocityऔर positionImpulseमें xऔर yअधिकतम परिमाण को प्रतिबंधित कर रहा हूं 25.0। परिणाम नीचे दिखाया गया है

यहां छवि विवरण दर्ज करें

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

इस विधि के साथ मेरी एकमात्र कमी यह है कि एक गैर-स्थैतिक शरीर का उपयोग करना संभव है कि वह किसी अन्य गैर-स्थिर शरीर को हिट करने के लिए पर्याप्त रूप से उस बिंदु पर पर्याप्त वेग दे सके जहां Resolverमॉड्यूल टकराव का पता लगाने में विफल हो जाएगा और अनुमति देगा दूसरे शरीर से गुजरने वाला दूसरा शरीर। (स्थिर घर्षण उदाहरण में आवश्यक वेग चारों ओर है 50.0, मैं केवल एक बार इसे सफलतापूर्वक करने में कामयाब रहा हूं, और फलस्वरूप मेरे पास इसका चित्रण करने वाला कोई एनीमेशन नहीं है)।


समाधान २

यह एक अतिरिक्त समाधान है, निष्पक्ष चेतावनी हालांकि: यह सीधा नहीं है।

व्यापक रूप से यह काम करता है जिस तरह से यह जांचना है कि शरीर को खींचा जा रहा है या नहीं, dragBodyएक स्थिर शरीर से टकरा गया है और यदि माउस बिना dragBodyअनुसरण किए बहुत दूर चला गया है। यदि यह पता लगाता है कि माउस के बीच अलगाव और dragBodyयह बहुत बड़ा हो गया है तो यह इवेंट श्रोता को हटा देता है और इसे एक अलग मूसमव फ़ंक्शन के साथ बदल देता है । यह फ़ंक्शन चेक करता है कि माउस शरीर के केंद्र के किसी निकटता के भीतर वापस आ गया है या नहीं। दुर्भाग्य से मैं ठीक से काम करने के लिए बिल्ट-इन विधि नहीं प्राप्त कर सका, इसलिए मुझे इसे सीधे शामिल करना पड़ा (जावास्क्रिप्ट में मुझसे अधिक जानकार किसी को भी यह पता लगाना होगा)। अंत में, यदि किसी घटना का पता चलता है तो वह सामान्य श्रोता पर वापस आ जाती है।Matter.js mouse.mousemovemouse.elementmousemove()Matter.Mouse._getRelativeMousePosition()mouseupmousemove

window.addEventListener('load', function() {
    var canvas = document.getElementById('world')
    var mouseNull = document.getElementById('mouseNull')
    var engine = Matter.Engine.create();
    var world = engine.world;
    var render = Matter.Render.create({ element: document.body, canvas: canvas,
                 engine: engine, options: { width: 800, height: 800,
                     background: 'transparent',showVelocity: true }});
    var body = Matter.Bodies.rectangle(400, 500, 200, 60, { isStatic: true}), 
        size = 50, counter = -1;
     
    var stack = Matter.Composites.stack(350, 470 - 6 * size, 1, 6, 
                                        0, 0, function(x, y) {
     return Matter.Bodies.rectangle(x, y, size * 2, size, {
         slop: 0.5, friction: 1,    frictionStatic: Infinity });
    });
    Matter.World.add(world, [ body, stack,
     Matter.Bodies.rectangle(400, 0, 800, 50, { isStatic: true }),
     Matter.Bodies.rectangle(400, 600, 800, 50, { isStatic: true }),
     Matter.Bodies.rectangle(800, 300, 50, 600, { isStatic: true }),
     Matter.Bodies.rectangle(0, 300, 50, 600, { isStatic: true })
    ]);

    Matter.Events.on(engine, 'beforeUpdate', function(event) {
     counter += 0.014;
     if (counter < 0) { return; }
     var px = 400 + 100 * Math.sin(counter);
     Matter.Body.setVelocity(body, { x: px - body.position.x, y: 0 });
     Matter.Body.setPosition(body, { x: px, y: body.position.y });
    });

    var mouse = Matter.Mouse.create(render.canvas),
     mouseConstraint = Matter.MouseConstraint.create(engine, { mouse: mouse,
         constraint: { stiffness: 0.2, render: { visible: false }}});
     
    var dragBody, overshoot = 0.0, threshold = 50.0, loc, dloc, offset, 
    bodies = Matter.Composite.allBodies(world), moveOn = true;
    getMousePosition = function(event) {
     var element = mouse.element, pixelRatio = mouse.pixelRatio, 
        elementBounds = element.getBoundingClientRect(),
        rootNode = (document.documentElement || document.body.parentNode || 
                    document.body),
        scrollX = (window.pageXOffset !== undefined) ? window.pageXOffset : 
                   rootNode.scrollLeft,
        scrollY = (window.pageYOffset !== undefined) ? window.pageYOffset : 
                   rootNode.scrollTop,
        touches = event.changedTouches, x, y;
     if (touches) {
         x = touches[0].pageX - elementBounds.left - scrollX;
         y = touches[0].pageY - elementBounds.top - scrollY;
     } else {
         x = event.pageX - elementBounds.left - scrollX;
         y = event.pageY - elementBounds.top - scrollY;
     }
     return { 
         x: x / (element.clientWidth / (element.width || element.clientWidth) *
            pixelRatio) * mouse.scale.x + mouse.offset.x,
         y: y / (element.clientHeight / (element.height || element.clientHeight) *
            pixelRatio) * mouse.scale.y + mouse.offset.y
     };
    };     
    mousemove = function() {
     loc = getMousePosition(event);
     dloc = dragBody.position;
     overshoot = ((loc.x - dloc.x)**2 + (loc.y - dloc.y)**2)**0.5 - offset;
     if (overshoot < threshold) {
         mouse.element.removeEventListener("mousemove", mousemove);
         mouse.element.addEventListener("mousemove", mouse.mousemove);
         moveOn = true;
     }
    }
    Matter.Events.on(mouseConstraint, 'startdrag', function(event) {
     dragBody = event.body;
     loc = mouse.position;
     dloc = dragBody.position;
     offset = ((loc.x - dloc.x)**2 + (loc.y - dloc.y)**2)**0.5;
     Matter.Events.on(mouseConstraint, 'mousemove', function(event) {
         loc = mouse.position;
         dloc = dragBody.position;
         for (var i = 0; i < bodies.length; i++) {                      
             overshoot = ((loc.x - dloc.x)**2 + (loc.y - dloc.y)**2)**0.5 - offset;
             if (bodies[i] != dragBody && 
                 Matter.SAT.collides(bodies[i], dragBody).collided == true) {
                 if (overshoot > threshold) {
                     if (moveOn == true) {
                         mouse.element.removeEventListener("mousemove", mouse.mousemove);
                         mouse.element.addEventListener("mousemove", mousemove);
                         moveOn = false;
                     }
                 }
             }
         }
     });
    });

    Matter.Events.on(mouseConstraint, 'mouseup', function(event) {
     if (moveOn == false){
         mouse.element.removeEventListener("mousemove", mousemove);
         mouse.element.addEventListener("mousemove", mouse.mousemove);
         moveOn = true;
     }
    });
    Matter.Events.on(mouseConstraint, 'enddrag', function(event) {
     overshoot = 0.0;
     Matter.Events.off(mouseConstraint, 'mousemove');
    });

    Matter.World.add(world, mouseConstraint);
    render.mouse = mouse;
    Matter.Engine.run(engine);
    Matter.Render.run(render);
});
<canvas id="world"></canvas>
<script src="https://cdnjs.cloudflare.com/ajax/libs/matter-js/0.10.0/matter.js"></script>

ईवेंट श्रोता स्विचिंग योजना लागू करने के बाद निकाय अब इस तरह का व्यवहार करते हैं

यहां छवि विवरण दर्ज करें

मैं इस परीक्षण किया है काफी अच्छी तरह से, लेकिन मैं इसे हर मामले में काम करेंगे गारंटी नहीं दे सकते। यह भी ध्यान दिया जाता है कि mouseupजब तक यह तब होता है जब माउस कैनवास के भीतर होता है, तब तक इस घटना का पता नहीं चलता - लेकिन यह किसी भी Matter.js का mouseupपता लगाने के लिए सही है, इसलिए मैंने इसे ठीक करने की कोशिश नहीं की।

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

यहां छवि विवरण दर्ज करें

इसे समाधान 1 के साथ जोड़कर हल किया जा सकता है ।

यहां एक अंतिम नोट, इसे केवल कुछ इंटरैक्शन के लिए लागू करना संभव है (जैसे कि एक स्थिर और एक गैर-स्थिर शरीर के बीच)। ऐसा करने से परिवर्तन पूरा होता है

if (bodies[i] != dragBody && Matter.SAT.collides(bodies[i], dragBody).collided == true) {
    //...
}

के लिए (जैसे स्थैतिक निकायों)

if (bodies[i].isStatic == true && bodies[i] != dragBody && 
    Matter.SAT.collides(bodies[i], dragBody).collided == true) {
    //...
}

विफल समाधान

यदि भविष्य में कोई भी उपयोगकर्ता इस सवाल पर आता है और अपने उपयोग के मामले के लिए दोनों समाधानों को अपर्याप्त पाता है, तो यहां कुछ ऐसे समाधान दिए गए हैं, जिनका मैंने प्रयास किया जो काम नहीं किया। क्या नहीं करना है इसके लिए एक प्रकार का गाइड।

  • mouse.mouseupसीधे कॉल करना : ऑब्जेक्ट तुरंत हटा दिया गया।
  • कॉलिंग mouse.mouseupके माध्यम से Event.trigger(mouseConstraint, 'mouseup', {mouse: mouse}): द्वारा ओवरराइड Engine.update, व्यवहार में कोई बदलाव नहीं।
  • खींची गई वस्तु को अस्थायी रूप से स्थिर बनाना: गैर-स्थैतिक (चाहे के माध्यम Matter.Body.setStatic(body, false)से body.isStatic = false) पर लौटने पर हटा दी गई वस्तु ।
  • करने के लिए बल की स्थापना (0,0)के माध्यम से setForceजब संघर्ष के करीब पहुंच: वस्तु अभी भी, के माध्यम से पारित कर सकते हैं में लागू करने की आवश्यकता होगी Resolverवास्तव में काम करने के लिए।
  • बदल रहा है mouse.elementके माध्यम से एक अलग कैनवास setElement()या परिवर्तनशील द्वारा mouse.elementसीधे: वस्तु तुरंत हटा।
  • अंतिम 'वैध' स्थिति में वस्तु को बदलना: अभी भी गुजरता है,
  • इसके माध्यम से व्यवहार बदलें collisionStart: असंगत टक्कर का पता लगाना अभी भी परमिट इस विधि से गुजरता है


आपके योगदान के लिए बहुत बहुत धन्यवाद! मैंने आपको इनाम से सम्मानित किया क्योंकि भले ही आपका समाधान सही नहीं था, लेकिन यह निश्चित रूप से आगे बढ़ने का रास्ता बताता है और आपने इस समस्या पर बहुत अधिक विचार और समय दिया है - धन्यवाद !! मैं अब निश्चित हूं कि यह समस्या अंततः MatterJS में एक फीचर-गैप है, और उम्मीद है कि यह चर्चा भविष्य में वास्तविक समाधान में योगदान करेगी।
d13

@ d13 धन्यवाद, मैं सहमत हूं कि समस्या अंत में अंतर्निहित कोड में है, लेकिन मुझे खुशी है कि मैं समाधान के कुछ अंश प्राप्त कर सकता हूं
विलियम मिलर

0

मैंने इस सुविधा को दूसरे तरीके से प्रबंधित किया होगा:

  • कोई "ड्रैग" (ताकि ऑफसेट बनाम ड्रैग की गई वस्तु के साथ ड्रैगपॉइंट का कोई कंटीन्यूअस एलाइन न हो)
  • माउसडाउन पर माउस पॉइंटर पोज़िशन ऑब्जेक्ट को फॉलो करने के लिए एक ओरिएंटेड वेग वेक्टर देता है
  • माउसअप पर अपना वेग वेक्टर रीसेट करें
  • मामले को अनुकरण बाकी करने दें

1
नहीं है कि थोड़े कैसे matter.jsशरीर को पहले से ही खींच रहा है? से यहाँ "... एक आभासी वसंत की तरह है कि माउस की दिशा में माउस के लिए अनुलग्न होता है तब खींच ... वसंत [शरीर के लिए] से जुड़ा हुआ है और खींचती है ...।"
भूत

केवल वेग सेट करना ओवरलैप को खींचने से रोकता है, स्पिंग दूसरों के माध्यम से शरीर को मजबूर करता है।
मोसु रज्जुनी

यह वास्तव में एक समाधान की ओर इशारा कर सकता है। अगर मैं सही तरीके से समझूं, तो इसका मतलब है कि माउसकॉन्स्ट्रेट में निर्मित मैटरजस का उपयोग न करना और माउस की स्थिति के आधार पर शरीर के वेग को मैन्युअल रूप से सेट करना। मुझे यकीन नहीं है कि यह कैसे लागू किया जाएगा, हालांकि, इसलिए यदि कोई भी इस बारे में विवरण पोस्ट कर सकता है कि शरीर को माउस की स्थिति में कैसे संरेखित करें, तो सेटपोजिशन या बाधा के बिना, कृपया करें।
d13

@ d13 आप अभी भी MatterJS पर भरोसा कर Resolverरहे हैं, यह तय करने के लिए कि टकराने वाले निकायों के बारे में क्या करना है - उस कोड के माध्यम से देखा गया है, मुझे उम्मीद है कि यह अभी भी कई परिस्थितियों में ड्रैग-थ्रू की अनुमति देने का निर्णय करेगा ..... यदि आप काम कर सकते हैं भी की अपने स्वयं के संस्करण को लागू किया solveVelocityऔर solvePositionलेकिन उस बिंदु पर आप फिर भी मैन्युअल कर रहे हैं क्या आप MatterJS सीधे हैंडल करना चाहते हैं ....
भूत

0

टकराव को नियंत्रित करने के लिए जब आपको खींचा जाता है तो आपको टक्कर फिल्टर और घटनाओं का उपयोग करने की आवश्यकता होती है ।

डिफ़ॉल्ट टकराव फिल्टर मास्क के साथ बॉडी बनाएं 0x0001। अस्थायी रूप से टकराव से बचने के लिए कैच startdragऔर enddragईवेंट जोड़ें और अलग-अलग बॉडी टकराव फ़िल्टर श्रेणी सेट करें ।

Matter.Events.on(mouseConstraint, 'startdrag', function(event) {
    event.body.collisionFilter.category = 0x0008; // move body to new category to avoid collision
});
Matter.Events.on(mouseConstraint, 'enddrag', function(event) {
     event.body.collisionFilter.category = 0x0001; // return body to default category to activate collision
});

window.addEventListener('load', function () {

  //Fetch our canvas
  var canvas = document.getElementById('world');

  //Setup Matter JS
  var engine = Matter.Engine.create();
  var world = engine.world;
  var render = Matter.Render.create({
                                      canvas: canvas,
                                      engine: engine,
                                      options: {
                                        width: 800,
                                        height: 800,
                                        background: 'transparent',
                                        wireframes: false,
                                        showAngleIndicator: false
                                      }
                                    });

  //Add a ball
  const size = 50;
  const stack = Matter.Composites.stack(350, 470 - 6 * size, 1, 6, 0, 0, (x, y) => {
    return Matter.Bodies.rectangle(x, y, size * 2, size, {
      collisionFilter: {
            mask: 0x0001,
      },
      slop: 0.5,
      friction: 1,
      frictionStatic: Infinity,
    });
  });

  Matter.World.add(engine.world, stack);

  //Add a floor
  var floor = Matter.Bodies.rectangle(250, 520, 500, 40, {
    isStatic: true, //An immovable object
    render: {
      visible: false
    }
  });
  Matter.World.add(world, floor);

  //Make interactive
  var mouseConstraint = Matter.MouseConstraint.create(engine, { //Create Constraint
    element: canvas,

    constraint: {
      render: {
        visible: false
      },
      stiffness: 0.8
    }
  });
  Matter.World.add(world, mouseConstraint);

  // add events to listen drag
  Matter.Events.on(mouseConstraint, 'startdrag', function (event) {
    event.body.collisionFilter.category = 0x0008; // move body to new category to avoid collision
  });
  Matter.Events.on(mouseConstraint, 'enddrag', function (event) {
    event.body.collisionFilter.category = 0x0001; // return body to default category to activate collision
  });

  //Start the engine
  Matter.Engine.run(engine);
  Matter.Render.run(render);

});
<canvas id="world"></canvas>
<script src="https://cdnjs.cloudflare.com/ajax/libs/matter-js/0.10.0/matter.min.js"></script>


1
आप उत्कृष्ट डेमो के लिए बहुत बहुत धन्यवाद! मैं वास्तव में विपरीत प्रभाव को प्राप्त करने की कोशिश कर रहा हूं: जब एक को दूसरे में घसीटा जाता है तो मुझे निकायों को प्रतिच्छेद करने से रोकने की आवश्यकता होती है।
d13

क्षमा करें यदि मैंने इस मुद्दे को गलत समझा। क्या आप स्पष्ट कर सकते हैं कि निकायों को प्रतिच्छेद करने से रोकने का क्या मतलब है? क्या आप बल लागू होने पर अन्य वस्तुओं के माध्यम से खींचने से रोकने की कोशिश कर रहे हैं?
तैमूर तेच्नुकवदेज़

1
उस मामले में यह खुला मुद्दा है और सीसीडी को लागू करने के लिए हार्ड-कोडिंग के बिना नहीं किया जा सकता है। देखिए: github.com/liabru/matter-js/issues/5
Temur Tchanukvadze

0

यह उनके GitHub पृष्ठ पर 672 जारी करने से संबंधित प्रतीत होता है, जो यह बताता है कि यह निरंतर टकराव जांच (सीसीडी) की कमी के कारण होता है।

इसे मापने का प्रयास किया गया है और इसके लिए कोड यहां पाया जा सकता है लेकिन यह मुद्दा अभी भी खुला है इसलिए ऐसा लग रहा है कि आपको इंजन बनाने के लिए इसमें सीसीडी का निर्माण करने की आवश्यकता हो सकती है।


1
आपके उत्तर के लिए धन्यवाद! मैंने इस पर विचार किया था, लेकिन मेरा मानना ​​है कि यह एक सीसीडी समस्या नहीं है, लेकिन एक समस्या "क्या होता है जब एक अजेय बल एक अयोग्य बाधा से मिलता है?" किसी तरह मुझे यह पता लगाने की आवश्यकता है कि निकायों को प्रतिच्छेद करने से रोकने के लिए बलों को कैसे बेअसर करना है।
d13
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.