Box2d और Libgdx

शुभ दिन।

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

मैंने LibGDX के विभिन्न पहलुओं / भागों के बारे में चरणों में लेख लिखने के लिए निर्धारित किया है, ताकि अंत में, कोई भी अपने खुद के खिलौने का अधिक या कम व्यावहारिक संस्करण बना सके। इस लेख में मैं Box2D के बारे में बात करना चाहूंगा, जो कि LibGDX में मौजूद है।


Box2D एक वास्तविक समय भौतिकी इंजन है और इसे दो-आयामी भौतिक वस्तुओं के साथ काम करने के लिए डिज़ाइन किया गया है। यदि आप साइड व्यू / प्लेटफ़ॉर्मर के साथ किसी प्रकार का गेम विकसित कर रहे हैं, तो यह सही समाधान है।
सभी आवश्यक कक्षाएं पैकेज में हैं com.badlogic.gdx.physics.box2d ।

एक आधार के रूप में, मैंने अपने एक लेख में वर्णित वास्तुकला को लिया। MVC पैटर्न का उपयोग किया जाता है।

GameScreen

गेमस्क्रीन स्क्रीन स्क्रीन, इनपुटप्रोसेसर , जो इसे सभी उपयोगकर्ता कार्यों को संसाधित करने की अनुमति देता है: क्लिक, आदि।

इसमें आवश्यक कक्षाएं बनाई गई हैं: MyWorld, WorldController, WorldRenderer।
लेख, जो MyWorld के बजाय एक आधार के रूप में लिया गया था, विश्व का उपयोग करता है। मुझे बॉक्स 2 डी पैकेज से उसी नाम के वर्ग के साथ संघर्ष न करने के लिए बदलना पड़ा।

@Override public void show() { //  ,        ,      MyWorld.CAMERA_WIDTH = MyWorld.CAMERA_HEIGHT* Gdx.graphics.getWidth()/Gdx.graphics.getHeight(); world = new MyWorld(); renderer = new WorldRenderer(world, MyWorld.CAMERA_WIDTH, MyWorld.CAMERA_HEIGHT,true); controller = new WorldController(world); Gdx.input.setInputProcessor(this); //     } 

स्वाभाविक रूप से, आपको सभी प्रसंस्करण विधियों को ओवरराइड करने की आवश्यकता है: टचडाउन, टचअप और अन्य।

एक उदाहरण के रूप में, टचडाउन को फिर से परिभाषित करें, टचअप करें ताकि हमारा चरित्र बाएं, दाएं और कूद सके।

 private void ChangeNavigation(int x, int y){ controller.resetWay(); //   ,  ,     () if(height-y > world.getPlayer().getPosition().y * renderer.ppuY) controller.upPressed(); //   ,  ,     if ( x< world.getPlayer().getPosition().x * renderer.ppuX) controller.leftPressed(); //   ,  ,     if (x> (world.getPlayer().getPosition().x )* renderer.ppuX) controller.rightPressed(); } @Override public boolean touchDown(int x, int y, int pointer, int button) { if (!Gdx.app.getType().equals(ApplicationType.Android)) return false; ChangeNavigation(x,y); return true; } @Override public boolean touchUp(int x, int y, int pointer, int button) { if (!Gdx.app.getType().equals(ApplicationType.Android)) return false; controller.resetWay(); return true; } @Override public boolean touchDragged(int x, int y, int pointer) { ChangeNavigation(x,y); return false; } 

गेमस्क्रीन में , यूजर एक्शन और कंट्रोलर अलार्म को प्रोसेस किया जा रहा है। यहां प्रमुख विधि render() , जो एक निश्चित अंतराल पर फायर करती है और तर्क को संसाधित करती है और वस्तुओं को खींचती है।

 @Override public void render(float delta) { Gdx.gl.glClearColor(0, 0, 0, 232F/255); Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT); controller.update(delta); renderer.render(delta); } 

MyWorld

MyWorld सिर्फ वस्तुओं का एक कंटेनर होगा। इसमें पैकेज से वर्ल्ड क्लास के इंस्टेंस का लिंक भी होगा। वस्तुओं को परिभाषित किया जाना चाहिए।

 World world; // Player player; //  Array<MovingPlatform> platforms = new Array<MovingPlatform>(); // public MovingPlatform groundedPlatform = null; 

ठीक है, ऑब्जेक्ट बनाएँ:

 public MyWorld(){ width = 30; height = 8; //   ,    () world = new World(new Vector2(0, -20), true); createWorld(); } private void createWorld(){ BodyDef def = new BodyDef(); def.type = BodyType.DynamicBody; Body boxP = world.createBody(def); player = new Player(boxP); player.getBody().setTransform(3.0f, 4.0f, 0); player.getBody().setFixedRotation(true); Body box = createBox(BodyType.StaticBody, 1, 1, 0); for(int i = 0; i < 10; i++) { box = createBox(BodyType.DynamicBody, (float)Math.random(), (float)Math.random(), 13); box.setTransform((float)Math.random() * 10f - (float)Math.random() * 10f, (float)Math.random() * 10 + 6, 0); } platforms.add(new MovingPlatform(world, 3F, 3, 1,0.25F, 2, 0, 2)); for(int i=1;i<width; ++i){ Body boxGround = createBox(BodyType.StaticBody, 1F, 1F, 0); boxGround.setTransform(i,0,0); } } private Body createBox(BodyType type, float width, float height, float density) { BodyDef def = new BodyDef(); def.type = type; Body box = world.createBody(def); PolygonShape poly = new PolygonShape(); poly.setAsBox(width, height); box.createFixture(poly, density); poly.dispose(); return box; } 

BodyDef - एक शरीर की परिभाषा जिसमें एक ठोस के बारे में सभी डेटा शामिल हैं। आप विभिन्न वस्तुओं के लिए इस परिभाषा का पुन: उपयोग कर सकते हैं।

BodyType टाइप - शरीर का प्रकार। यह तीन संभावितों में से एक हो सकता है:
स्थिर - शून्य द्रव्यमान, शून्य गति, आप केवल इसे प्रोग्रामेटिक रूप से स्थानांतरित कर सकते हैं;
गतिज - शून्य द्रव्यमान, गैर-शून्य वेग, स्थानांतरित किया जा सकता है;
गतिशील - सकारात्मक द्रव्यमान, गैर-शून्य वेग, स्थानांतरित किया जा सकता है।

स्थैतिक का उपयोग उन वस्तुओं के लिए किया जाना चाहिए जिन्हें स्थानांतरित करने की आवश्यकता नहीं है। एक उदाहरण के रूप में: फर्श, दीवारें।

Body , वास्तव में, शरीर ही है।
Body वस्तुओं को setTransform() विधि का उपयोग करके घुमाया और घुमाया जा सकता है।

खिलाड़ी

खिलाड़ी वर्ग एक चरित्र है:

 public class Player { final static float MAX_VELOCITY = 3f; public final static float SPEED = 5f; public final static float SIZE = 0.8f; public Fixture playerPhysicsFixture; public Fixture playerSensorFixture; Body box; public Player(Body b){ box = b; PolygonShape poly = new PolygonShape(); poly.setAsBox(0.4f, 0.4f); playerPhysicsFixture = box.createFixture(poly, 3); poly.dispose(); CircleShape circle = new CircleShape(); circle.setRadius(0.41f); circle.setPosition(new Vector2(0, 0f)); playerSensorFixture = box.createFixture(circle, 1); setFriction(10F); circle.dispose(); box.setBullet(true); } public Body getBody(){ return box; } //    public void setFriction(float f){ playerSensorFixture.setFriction(f); playerPhysicsFixture.setFriction(f); } public Vector2 getPosition(){ return box.getPosition(); } public Vector2 getVelocity() { return velocity; } Vector2 velocity = new Vector2(); public void update(float delta) { Vector2 vel = box.getLinearVelocity(); velocity.y = vel.y; box.setLinearVelocity(velocity); if(isJump) {box.applyLinearImpulse(0, 8, box.getPosition().x, box.getPosition().y); isJump = false;} } boolean isJump = false; public void jump(){ isJump = true; } public void resetVelocity(){ getVelocity().x =0; getVelocity().y =0; } } 

इस उदाहरण में, मैंने दिखाया कि Box2D में आप कीनेमेटिक जोड़े से ऑब्जेक्ट बना सकते हैं। इस मामले में, खिलाड़ी एक सरेस से जोड़ा हुआ आयत और एक चक्र होता है।

सिद्धांत रूप में, आप वस्तुओं को विभिन्न तरीकों से स्थानांतरित कर सकते हैं, स्थिति में एक स्पष्ट परिवर्तन तक। लेकिन Box2D में इसके लिए दो विशेष तरीके हैं:
applyLinearImpulse() - ऑब्जेक्ट की गति सेट करें। जैसा कि वास्तविक दुनिया में, यदि आप किसी वस्तु को धक्का देते हैं, तो गति के अनुसार, शरीर तब तक चलेगा जब तक कि घर्षण गति को समाप्त नहीं कर देता।
setLinearVelocity() - आंदोलन की गति निर्धारित करें। एक नाड़ी के विपरीत, गति तब तक स्थिर रहेगी जब तक आप इसे नहीं बदलते।

मैं व्यक्तिगत रूप से X अक्ष के साथ जाने के लिए setLinearVelocity() का उपयोग करता setLinearVelocity() । जब आप अपनी उंगली को व्हीलचेयर पर रखते हैं, तो फारसी हिल जाएगा, जब जारी किया जाता है, तो चरित्र बंद हो जाएगा। यदि आप क्षैतिज रूप से स्थानांतरित करने के लिए applyLinearImpulse() का उपयोग करते हैं, तो स्क्रीन से आपकी उंगली हटाने के बाद भी चरित्र कुछ समय के लिए चलेगा।
सिद्धांत रूप में, कभी-कभी आप बाईं / दाईं ओर जाने के applyLinearImpulse() का applyLinearImpulse() कर सकते applyLinearImpulse() । एक उदाहरण के रूप में, यदि कोई चरित्र एक फिसलन सतह (बर्फ, एक उदाहरण के रूप में) पर चलता है।

box.setBullet(true); इंगित करता है कि टकरावों का पता लगाने पर शरीर को एक गोली माना जाना चाहिए।

चल रहा मंच

MovingPlatform एक मूविंग प्लेटफॉर्म है।

 public class MovingPlatform { Body platform; Vector2 pos = new Vector2(); Vector2 dir = new Vector2(); Vector2 vel = new Vector2(); float maxDist = 0; float width; //Vector2 l = new Vector2(); public MovingPlatform(World world, float x, float y, float width, float height, float dx, float dy, float maxDist) { platform = createBox(world, BodyType.KinematicBody, width, height, 1); this.width = width; pos.x = x; pos.y = y; dir.x = dx; dir.y = dy; vel.x = dx; vel.y = dy; this.maxDist = maxDist; platform.setTransform(pos, 0); platform.getFixtureList().get(0).setUserData("p"); platform.setUserData(this); } public void resume(){ dir.x= vel.x; dir.y = vel.y; } public void pause(){ vel.x = dir.x; vel.y = dir.y; dir.x = 0; dir.y = 0; platform.setLinearVelocity(dir); } public void update(float deltaTime) { if(dir.x < 0 && platform .getPosition().x < pos.x-maxDist) { platform .getPosition().x =pos.x; dir.mul(-1); } if(dir.x > 0 && platform .getPosition().x> pos.x+maxDist) { platform .getPosition().x =pos.x+maxDist; dir.mul(-1); } platform.setLinearVelocity(dir); } private Body createBox(World world,BodyType type, float width, float height, float density) { BodyDef def = new BodyDef(); def.type = type; Body box = world.createBody(def); PolygonShape poly = new PolygonShape(); poly.setAsBox(width/2, height/2); Fixture f = box.createFixture(poly, density); poly.dispose(); return box; } } 

मंच मूल स्थिति से एक निश्चित दूरी तय करेगा।

WorldController

WorldController में, update() विधि में उपयोगकर्ता क्रियाओं के जवाब में तर्क दिया जाता है।

 boolean grounded ; public void update(float delta) { Array<MovingPlatform> platforms = world.getPlatforms(); //   for(int i = 0; i < platforms.size; i++) { MovingPlatform platform = platforms.get(i); platform.update(Math.max(1/60.0f, delta)); } grounded = isPlayerGrounded(Gdx.graphics.getDeltaTime()); //  processInput(); //   world.getPlayer().update(delta); } 

उपयोगकर्ता क्लिक को संसाधित करना और आंदोलन की एक नई दिशा का संकेत देना आवश्यक है।

  //            private void processInput() { Player player = world.getPlayer(); //    if (keys.get(Keys.LEFT)) player.getVelocity().x =- Player.SPEED; //    if (keys.get(Keys.RIGHT)) player.getVelocity().x = Player.SPEED; //   if (keys.get(Keys.UP)) //    if(grounded) // player.jump(); //    if(!grounded) //  world.getPlayer().setFriction(0f); //   else{ if(keys.get(Keys.RIGHT) || keys.get(Keys.LEFT)) world.getPlayer().setFriction(0.2f); else world.getPlayer().setFriction(100f); } } 

यह जांचने के लिए केवल एक विधि लिखने के लिए बनी हुई है कि चरित्र जमीन पर है या नहीं। ऐसा करने के लिए, आपको वस्तुओं के सभी संपर्कों की एक सूची प्राप्त करने की आवश्यकता है। उनमें से, चरित्र के संपर्कों का चयन करें। यदि संपर्कों के बीच कोई ऐसी वस्तु है जो वर्ण के नीचे है, तो यह एक ठोस सतह पर है।

  private boolean isPlayerGrounded(float deltaTime) { world.groundedPlatform = null; List<Contact> contactList = world.getWorld().getContactList(); for(int i = 0; i < contactList.size(); i++) { Contact contact = contactList.get(i); if(contact.isTouching() && (contact.getFixtureA() == world.getPlayer().playerSensorFixture || contact.getFixtureB() == world.getPlayer().playerSensorFixture)) { Vector2 pos = world.getPlayer().getPosition(); WorldManifold manifold = contact.getWorldManifold(); boolean below = true; for(int j = 0; j < manifold.getNumberOfContactPoints(); j++) { below &= (manifold.getPoints()[j].y < pos.y - 0.4f); } if(below) { if(contact.getFixtureA().getUserData() != null && contact.getFixtureA().getUserData().equals("p")) { world.groundedPlatform = (MovingPlatform)contact.getFixtureA().getBody().getUserData(); } if(contact.getFixtureB().getUserData() != null && contact.getFixtureB().getUserData().equals("p")) { world.groundedPlatform = (MovingPlatform)contact.getFixtureB().getBody().getUserData(); } return true; } return false; } } return false; } 

चरित्र कहां है इसके आधार पर, घर्षण का बल बदल जाता है। शून्य घर्षण के साथ, चरित्र मंच के साथ नहीं चलेगा, लेकिन जगह में रहेगा, जैसे कि स्लाइड करना है।


यह मानना ​​तर्कसंगत है कि अधिक घर्षण सेट किया जाना चाहिए। मैंने विदेशी मैनुअल को देखा ... यह तरीका हमेशा काम नहीं करता है।

इस मामले में, आप दूसरे तरीके से जा सकते हैं: घर्षण बल को चरित्र में नहीं, बल्कि संपर्क में बदलें। यह है, isPlayerGrounded विधि में, कुछ इस तरह लिखें:

 if (!keys.get(Keys.LEFT) && !keys.get(Keys.RIGHT)) contact.setFriction(200F); else contact.setFriction(0F); 

फिर, अगर चरित्र बस खड़ा है, तो वह बहुत घर्षण के कारण मंच के साथ आगे बढ़ेगा। यदि चरित्र को स्थानांतरित करने की आवश्यकता है, तो घर्षण को कम करें।



वास्तव में सब कुछ। हमारा चरित्र बाएं और दाएं, साथ ही कूद भी सकता है। यह बेतरतीब ढंग से उत्पन्न ब्लॉकों को भी स्थानांतरित कर सकता है।

अब आपको केवल वस्तुओं को प्रस्तुत करने की आवश्यकता है।

WorldRenderer

WorldRenderer वर्ग में, WorldRenderer को WorldRenderer ।

 public class WorldRenderer { Box2DDebugRenderer renderer; public static float CAMERA_WIDTH = 10f; public static float CAMERA_HEIGHT = 15f; public float ppuX; public float ppuY; MyWorld world; public OrthographicCamera cam; public WorldRenderer(MyWorld world, float w, float h, boolean debug) { renderer = new Box2DDebugRenderer(); this.world = world; CAMERA_WIDTH = w; CAMERA_HEIGHT = h; ppuX = (float)Gdx.graphics.getWidth() / CAMERA_WIDTH; ppuY = (float)Gdx.graphics.getHeight() / CAMERA_HEIGHT; this.cam = new OrthographicCamera(CAMERA_WIDTH, CAMERA_HEIGHT); SetCamera(CAMERA_WIDTH / 2f, CAMERA_HEIGHT / 2f); } public void SetCamera(float x, float y){ this.cam.position.set(x, y,0); this.cam.update(); } public void dispose(){ world.dispose(); } public void render(float delta) { renderer.render(world.getWorld(), cam.combined); world.getWorld().step(delta, 4, 4); } } 

render() विधि में ही रेंडरिंग होती है। इस उदाहरण का उपयोग ऑब्जेक्ट्स की सीमाओं को प्रदर्शित करने के लिए डीबग मोड में Box2DebugRenderer को खींचने के लिए किया जाता है। आपके आवेदन के अंतिम संस्करण में, render() विधि में, आपको सभी ऑब्जेक्ट्स के लिए कुछ स्प्राइट्स आउटपुट करने की आवश्यकता है।

world.getWorld().step(delta, 4, 4); आवृत्ति को इंगित करता है जिसके साथ भौतिकी को अद्यतन करना है। ज्यादातर मामलों में, मुझे लगता है कि ड्राइंग की तुलना में अधिक बार भौतिकी को अपडेट करने की आवश्यकता नहीं है।
PS मैं खुद Box2D का अध्ययन करना शुरू करता हूं, इसलिए मुझे किसी भी सुझाव और आलोचना पर खुशी होगी।