ActionScript 3 पर Box2D का उपयोग करके खेल विकास

शुभ दिन, प्रिय पाठक!
हाल ही में, एक लेख प्रकाशित किया गया था जिसमें बताया गया था कि बॉक्स 2 डी इंजन के साथ कैसे काम किया जाए।
हालांकि, साइट पर इंजन संस्करण 2.1a था, जिसके साथ काम, दुर्भाग्य से, लेख में प्रदान किए गए काम से अलग था। दुर्भाग्य से, इंजन के इस संस्करण पर अल्प विदेशी प्रलेखन ने मुझे बहुत कुछ समझा दिया। मैं अपने शोध का हिस्सा आपके साथ साझा करना चाहूंगा, प्रिय पाठक।


सबसे पहले, मैं संस्करण 2.0 से परिवर्तनों के बारे में बात करना चाहूंगा।

• आंकड़ों के ज्यामितीय गुणों को भौतिक से अलग किया गया था। अब भौतिक गुण प्रकार b2FixtureDef के हैं, जबकि ज्यामितीय गुणधर्म b2BodyDef के हैं। हमारी ज्यामिति में भौतिक गुणों को लागू करने के लिए, हमें भौतिक गुणों के पैरामीटर के साथ हमारे शरीर (b2Body) के लिए CreateFixture फ़ंक्शन को कॉल करना होगा।
  

  body.CreateFixture(fixtureDef); 

• इसके अलावा अब हमें अपनी वस्तु का प्रकार b2BodyDef में निर्दिष्ट करना होगा। इस प्रकार के 3 हैं:
  1. स्थिर
  2. गतिशील
  3. काइनेमैटिक (यदि आप वस्तु को स्थानांतरित करना चाहते हैं, लेकिन इसे अन्य वस्तुओं के साथ स्थानांतरित करना असंभव था)
• अब आपको हमारी दुनिया के आकार को इंगित करने की आवश्यकता नहीं है।
• बहुभुज की संख्या पर सीमा को हटा दिया गया है।

नया संस्करण सीखने के लिए, आइए एक उदाहरण देखें।

सबसे पहले, हमें एक नया प्रोजेक्ट बनाने की जरूरत है (मैं FlashDevelop का उपयोग करता हूं) और ऐसा कुछ देखता हूं:

 package { import flash.display.Sprite; import flash.events.Event; public class Main extends Sprite { public function Main():void { if (stage) init(); else addEventListener(Event.ADDED_TO_STAGE, init); } public function init(e:Event = null):void { removeEventListener(Event.ADDED_TO_STAGE, init); } } } 

अगला, हम इंजन के 2.1a संस्करण को डाउनलोड करते हैं और इसे हमारे प्रोजेक्ट के कोड के साथ फ़ोल्डर में छोड़ देते हैं।
हम उन वर्गों को आयात करते हैं जिनकी हमें आवश्यकता है:

 import Box2D.Common.Math.b2Vec2; import Box2D.Dynamics.*; import Box2D.Collision.Shapes.b2PolygonShape; import Box2D.Collision.Shapes.b2CircleShape; import flash.display.Sprite; import flash.events.Event; import flash.events.KeyboardEvent; import flash.utils.getTimer; 

वे चर बनाएं जिनकी हमें आवश्यकता है:

 public var PIXELS_TO_METRE:Number = new Number(30); //   .  ,   Box2D     . public var world:b2World; // . public var ball:b2Body; //. public var timer:Number = new Number(0); //      . 

ADDED_TO_STAGE हैंडलर निकालने के बाद, हम अपनी दुनिया बनाते हैं:

 world = new b2World(new b2Vec2(0, 10), true); 

पहला पैरामीटर जो b2Vec2 प्रकार की वस्तु लेता है वह हमारी दुनिया में गुरुत्वाकर्षण है। इस मामले में, मैंने इसे 10 अंक से y अक्ष नीचे निर्देशित किया है, जो मुझे सूट करता है।
दूसरा पैरामीटर दुनिया में वस्तुओं के लिए नींद की अनुमति / निषेध है।

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

 public function addBox(x:Number, y:Number, width:Number, height:Number, dyn:int = 0):b2Body { var bodyDef:b2BodyDef = new b2BodyDef(); bodyDef.position.Set((x + width / 2) / PIXELS_TO_METRE, (y + height / 2) / PIXELS_TO_METRE); if (dyn == 1) bodyDef.type = b2Body.b2_dynamicBody; var content:Sprite = new Sprite(); content.graphics.beginFill(0x000000); content.graphics.drawRect(0 - width / 2, 0 - height / 2, width, height); bodyDef.userData = content; addChild(bodyDef.userData); var boxShape:b2PolygonShape = new b2PolygonShape(); boxShape.SetAsBox(width / 2 / PIXELS_TO_METRE, height / 2 / PIXELS_TO_METRE); var fixtureDef:b2FixtureDef = new b2FixtureDef(); fixtureDef.shape = boxShape; fixtureDef.density = dyn; var body:b2Body = world.CreateBody(bodyDef); body.CreateFixture(fixtureDef); return(body); } 

बॉडीफैड ऑब्जेक्ट हमारे आयत के मापदंडों को संग्रहीत करता है: निर्देशांक, रोटेशन और सामग्री। प्रारंभ में, समन्वय बिंदु हमारी आयत का केंद्र है। चूंकि यह मेरे लिए असुविधाजनक है, इसलिए मैंने ऊपरी बाएं बिंदु की गणना की, जिसे एक पैरामीटर के रूप में दर्ज किया जाएगा।
हमारी परियोजना में गतिशील (जीवित) दोनों आयताकार और स्थिर होंगे। हम अपने पैरामीटर (dyn) की जांच करते हैं और यदि आवश्यक हो तो प्रकार सेट करते हैं।
अगला, मैं केंद्र से शुरू होने वाले आयत को, इसके ग्राफिक घटक को आकर्षित करता हूं।
प्रकार b2PolygonShape के ऑब्जेक्ट की SetAsBox विधि ऑब्जेक्ट के भौतिक भाग के लिए एक आयत प्रदान करती है। मापदंडों के रूप में, यह मीटर भी लेता है और बीच से गिनती शुरू करता है।
फ़िक्चरडिफ ऑब्जेक्ट हमारी आयत का भौतिक पैरामीटर है: गतिशीलता, घनत्व, लोच और भौतिक मॉडल। मैंने घनत्व और लोच जैसे मापदंडों का उपयोग नहीं किया।
इसके बाद, हम अपनी दुनिया के ऑब्जेक्ट के बारे में डेटा भेजते हैं।

अगला, मैंने गेंद बनाने के लिए एक समारोह बनाया, हमारी परियोजना का नायक:

 public function addBall(x:Number, y:Number, radius:Number):void { var bodyDef:b2BodyDef = new b2BodyDef(); bodyDef.position.Set((x + radius) / PIXELS_TO_METRE, (y + radius) / PIXELS_TO_METRE); bodyDef.type = b2Body.b2_dynamicBody; var content:Sprite = new Sprite(); content.graphics.beginFill(0x000000); content.graphics.drawCircle(0, 0, radius); bodyDef.userData = content; addChild(bodyDef.userData); var circShape:b2CircleShape = new b2CircleShape(radius / PIXELS_TO_METRE); var fixtureDef:b2FixtureDef = new b2FixtureDef(); fixtureDef.shape = circShape; fixtureDef.density = 1; ball = world.CreateBody(bodyDef); ball.CreateFixture(fixtureDef); } 

एक गेंद बनाना एक आयत बनाने के समान है, और इसके लिए मैं इस पर विचार नहीं करूंगा।

एक त्रिभुज बनाएँ, जिसकी हमारे पास एक सीढ़ी होगी:

 public function addTriangle(x:Number, y:Number, size:Number):void { var bodyDef:b2BodyDef = new b2BodyDef(); bodyDef.position.Set(x / PIXELS_TO_METRE, y / PIXELS_TO_METRE); var content:Sprite = new Sprite(); content.graphics.beginFill(0x000000); content.graphics.moveTo(size, 0); content.graphics.lineTo(0, size); content.graphics.lineTo(size, size); bodyDef.userData = content; addChild(bodyDef.userData); var polyDef:b2PolygonShape = new b2PolygonShape(); polyDef.SetAsArray([ new b2Vec2(size / PIXELS_TO_METRE, size / PIXELS_TO_METRE), new b2Vec2(0, size / PIXELS_TO_METRE), new b2Vec2(size / PIXELS_TO_METRE, 0) ]); var fixtureDef:b2FixtureDef = new b2FixtureDef(); fixtureDef.shape = polyDef; fixtureDef.density = 0; var body:b2Body = world.CreateBody(bodyDef); body.CreateFixture(fixtureDef); } 

भौतिक मॉडल बनाने के अपवाद के साथ, यहां सब कुछ समान है। यहाँ भौतिक मॉडल b2PolygonShape प्रकार की एक वस्तु है। चूंकि कोई टेम्प्लेट नहीं है (जैसे अडबॉक्स), हम स्वयं एक त्रिकोण खींचते हैं जिसमें वैक्टर की एक सरणी होती है। गिनती सरणी के अंतिम तत्व से पहली तक शुरू होती है।

अगला, हम क्रेटऑब्जेक्ट्स नामक एक फंक्शन बनाते हैं, जहां हम लिखते हैं:

 public function creteObjects():void { addBall(10, 400, 50); addBox(0, 580, 450, 20, 0); addBox(250, 540, 200, 40, 0); addTriangle(210, 540, 40); addBox(610, 540, 190, 60); addBox(-10, 0, 10, 600); addBox(800, 0, 10, 600); var m1:b2Body = addBox(430, 540, 20, 5, 0); var m2:b2Body = addBox(451, 540, 20, 5, 1); var m3:b2Body = addBox(472, 540, 20, 5, 1); var m4:b2Body = addBox(493, 540, 20, 5, 1); var m5:b2Body = addBox(514, 540, 20, 5, 1); var m6:b2Body = addBox(535, 540, 20, 5, 1); var m7:b2Body = addBox(556, 540, 20, 5, 1); var m8:b2Body = addBox(577, 540, 20, 5, 1); var m9:b2Body = addBox(598, 540, 20, 5, 0); } 

अंतिम तत्व हमारे भविष्य के पुल हैं।
आगे हमें अपने पुल के तत्वों को जोड़ने की जरूरत है।
हम creteObjects के अंत में निम्नलिखित लिखते हैं:

 var jointDef:b2RevoluteJointDef = new b2RevoluteJointDef(); jointDef.enableLimit = true; jointDef.lowerAngle = 0; jointDef.upperAngle = 0.1; jointDef.Initialize(m1, m2, m1.GetWorldCenter()); world.CreateJoint(jointDef); jointDef.Initialize(m2, m3, m2.GetWorldCenter()); world.CreateJoint(jointDef); jointDef.Initialize(m3, m4, m3.GetWorldCenter()); world.CreateJoint(jointDef); jointDef.Initialize(m4, m5, m4.GetWorldCenter()); world.CreateJoint(jointDef); jointDef.Initialize(m5, m6, m5.GetWorldCenter()); world.CreateJoint(jointDef); jointDef.Initialize(m6, m7, m6.GetWorldCenter()); world.CreateJoint(jointDef); jointDef.Initialize(m7, m8, m7.GetWorldCenter()); world.CreateJoint(jointDef); jointDef.Initialize(m8, m9, m8.GetWorldCenter()); world.CreateJoint(jointDef); 

सबसे पहले, हम अपने बंडल का कॉन्फ़िगरेशन बनाते हैं, जिसमें हम सीमाएं लागू करते हैं ताकि यह अधिक हिला न हो।
अगला, हम सभी तत्वों को एक साथ जोड़ते हैं।

दुनिया की सभी वस्तुएं तैयार हैं और काम कर रही हैं। लेकिन अगर हम आवेदन को संकलित करते हैं, तो हमें कुछ भी अच्छा नहीं दिखाई देगा। क्यों? हमने रेंडर नहीं किया।
Init फ़ंक्शन के अंत में, हम ENTER_FRAME इवेंट बढ़ाते हैं:

 stage.addEventListener(Event.ENTER_FRAME, onEnterFrame); 

वास्तव में onEnterFrame फ़ंक्शन का कोड:

 public function onEnterFrame(e:Event = null):void { world.Step(1 / 30, 10, 10); for (var bb:b2Body = world.GetBodyList(); bb; bb = bb.GetNext()){ if (bb.GetUserData() is Sprite) { var sprite:Sprite = bb.GetUserData() as Sprite; sprite.x = bb.GetPosition().x * PIXELS_TO_METRE; sprite.y = bb.GetPosition().y * PIXELS_TO_METRE; sprite.rotation = bb.GetAngle() * (180 / Math.PI); } } } 

स्टेप फंक्शन हमारी दुनिया को अपडेट करता है। एक पैरामीटर के रूप में, वस्तुओं को अपडेट करने में कितनी बार लगता है। सेकंड में।
अगला, हम दुनिया में सभी वस्तुओं को प्राप्त करते हैं और उनकी स्थिति और रोटेशन को अपडेट करते हैं।

आप परीक्षण कर सकते हैं। सब कुछ ठीक काम करता है, यह देखते हुए कि हम अपने चरित्र को नियंत्रित नहीं कर सकते। अब इसे ठीक करो।



एक कीस्ट्रोक हैंडलर जोड़ें:

 stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown); 

OnKeyDown फ़ंक्शन बनाएँ:

 public function onKeyDown(e:KeyboardEvent):void { if (e.keyCode == 39 && getTimer() - p > 200) { ball.ApplyImpulse(new b2Vec2(10, 0), ball.GetPosition()); p = getTimer(); }else if (e.keyCode == 37 && getTimer() - p > 200) { ball.ApplyImpulse(new b2Vec2( -10, 0), ball.GetPosition()); p = getTimer(); } } 

ApplyImpulse फ़ंक्शन किसी दिए गए बल वेक्टर और स्थिति के साथ किसी ऑब्जेक्ट पर एक धक्का लागू करता है।
मैंने कीस्ट्रोके को भी याद किया और अगला 200 मिलीसेकंड से पहले नहीं होगा।

अंत में, हमें यह मिलता है। प्रोजेक्ट स्रोतों को यहां डाउनलोड करें ।
हमने बॉक्स 2 डी दुनिया में वस्तुओं के निर्माण की संक्षिप्त चर्चा की, दोनों मानक और हमारे। उन्होंने स्नायुबंधन का उपयोग करके एक पुल बनाया और चरित्र को चलना सिखाया। गुड लक, प्रिय पाठक!