Using Box2d in Libgdx Game Part III

Hi,

In this post we would make a box2d object manager to handle creation/deletion of objects.

First we would make some changes in the BaseBoxObject class made in the last post to add option of deleting an object from the world and also an abstract function to draw the texture which would have to be implemented in the child classes.

BaseBoxObject:

public abstract class BaseBoxObject{
        ...........
       protected boolean isActive;
       public abstract void Draw(SpriteBatch sp);

       public void Destroy(World world){
                if(isActive){
                         world.destroyBody(body);
                         isActive=false;
                }
       } 
       public void ChangeBodyIndex(int newIndex){
            userData.Set(newIndex,userData.GetCollisionGroup());
            body.setUserData(userData);
       } 
}

BoxObjectManager:

public class BoxObjectManager{
      ArrayList<BaseBoxObject> objects;
      ArrayList<BaseBoxObject> deleteList;
      World world;
      public BoxObjectManager(Vector2 gravity){ 
           world=new World(gravity,true);
          objects=new ArrayList<BaseBoxObject>();
          deleteList=new ArrayList<BaseBoxObject>();
      }

      public BaseBoxObject AddObject(Vector2 pos,int objType,int collisionGroup){
           BaseBoxObject temp;
           //CREATE different objects depending on the type considering we have to child classes 
           // Object1 and Object2 inheriting the base class BaseBoxObject
           swtich (objType){
                case OBJECT1: temp=new Object1(world,pos,objects.size(),collisionGroup);
                              break;
                case OBJECT2: temp=new Object2(world,pos,objects.size(),collisionGroup);
                              break;

           }
           objects.add(temp);
           return temp;
      } 

      public void Update(float dt){
           for(BaseBoxObject del:deleteList){
                   int index=del.GetBoxId();
                   BaseBoxObject replace=objects.get(objects.size()-1);
                   replace.setBodyIndex(index);  //Update the index to the object to be removed
                   objects.set(index,replace);
                   objects.remove(objects.size()-1);
           }
           for(BaseBoxObject obj:objects){
                   obj.Update(dt);
           }
           deleteList.clear();
      }
      public void Draw(SpriteBatch sp){
           for(BaseBoxObject obj:objects){
                   obj.Draw(sp);
           }
      }
      public void AddForDeletion(BaseBoxObject obj){
             deleteList.add(obj);
      } 
}

In update we first go through the objects in the delete list and take the last object from the main objects arraylist and set it to the delete objects position. We also change their ids  (replace.setBodyIndex(index)) so we don’t have issues while fetching the objects from the array. If the objects are stored in a sorted manner (maybe sorted by position), then every time an object is removed you would have to update the objects after that index i.e. increment their indices by one and move them all up by one in the array.

So in main game class we would instantiate a BoxObjectManager object and use it add to add objects to the world and delete them. Below is an example.

public class MainGame(){
          ......
          BoxObjectManager boxObjectManager;
          void Init(){
                 boxObjectManager=new BoxObjectManager(gravity);
                  ......
           }
           void Render(SpriteBatch sp){
                    boxObjectManager.Draw(sp);
           }
           void Update(float dt){
                    boxObjectManager.Update(dt);
             }
           void AddObject(Vector2 pos,int type,int collisionGroup){
                   Object1 obj=(Object1)boxObjectManager.GetNewObject(pos,type,collisionGroup);
                   //Set Object properties ..
                   obj.SetTexture(....);
                   obj.SetSensor(...);
                    .....
            }
            void DeleteObject(BaseBoxObject obj){
                    boxObjectManager.AddForDeletion(obj);
            }
}

So this is a rough implementation of how we can create all box2d objects in one class and have unique references to them. This code can be improved a lot further and it is just a direction of how to handle the objects.

Sensor :

In box2d we can set a property called “sensor” to true which makes body transparent in the  sense that when a body collides with a sensor body it does not deflect or change direction i.e. no collision response is done though we receive the information that the body has collided. So they are really useful in implement collectibles like stars,healths,powerups as usually we don’t want the protagonist to deflect on colliding with them.

Deleting Object:

In balloon shooter we never really destroyed a box2d body during a game. We created pools of arrows as they were the only dynamicaly created bodies (others numbers were fixed during a level) so whenever a arrow collided, we just set a custom boolean flag “active” to false so while handling collisions we ignored that object. For balloons we just made them inactive so for a collision nothing was done with them. We don’t know how efficient that might be but we had very few bodies in the screen so we got away with it. And when a level was over/restarted we deleted all the bodies/fixtures in the world, cleared the arraylist and loaded them again.

For checking collisions we have to implement an interface called ContactListener which would handle collisions between different types of objects in the game and handle the responses.

We would implement ContactListener in BoxObjectManager as it contains references for all the objects so it would be easy to handle deletion.

There are 4 functions which have to be implemented when using ContactListener.

BeginContact:  This event is called when two fixtures begin to overlap or start to collide. Usually we would check here if the body is to be removed or not.

EndContact: This event is called when the overlap between the two fixtures ends. This can be called when we delete a body/fixture as the contact would stop existing for that body/fixture.

PreSolve:This is called after the collision is detected but before the response has been calculated. This is good if we don’t want the object to behave in normal way for e.g. maybe tunnel through a wall from one direction and not from another.

PostSolve: In this event we get the collision impulse results.  But mostly if we would like to change the collision response we would do it in PreSolve.

public class BoxObjectManager implements ContactListener{
............. 
      public BoxObjectManager(){
            .................
            //After initializing the world the conactlistener has to enabled for the world
            world.setContactListener(this); 
      }
      @Override
      public void beginContact(Contact contact) {
             // TODO Auto-generated method stub
            Fixture f1=contact.getFixtureA();
            Body b1=f1.getBody();
            Fixture f2=contact.getFixtureB();
            Body b2=f2.getBody();
            BoxUserData userData1 = (BoxUserData) b1.getUserData();
            BoxUserData userData2 = (BoxUserData) b2.getUserData();
            //Depending on type of body we can handle 
           if(userData1.GetCollisionGroup()==OBJECT1  && userData2.GetCollisionGroup()==OBJECT2)
                     HandleObject12Collision(userData1,userData2);
           if(userData1.GetCollisionGroup()==OBJECT2  && userData2.GetCollisionGroup()==OBJECT1)
                     HandleObject12Collision(userData2,userData1);
      }
      void HandleObject12Collision(BoxUserData userData1,BoxUserData userData2){
                   Object1 object1=(Object1)objects.get(userData1.GetBoxID());
                   Object2 object2=(Object2)objects.get(userData2.GetObjectID());
                   //Change health/color etc of object1/2
                  //Maybe then add object2 for deletion
                   AddForDeletion(object2)
       } 
      @Override
       public void endContact(Contact contact) {
             // TODO Auto-generated method stub
      }
      @Override
       public void preSolve(Contact contact, Manifold oldManifold) {
      }
      @Override
       public void postSolve(Contact contact, ContactImpulse impulse) {
       // TODO Auto-generated method stub
      }

}

In this way we can write specific responses for collisions between different types of classes. The BoxUserData class holds the variable collisionGroup/objectType value to tell which type of object it is. Then we get the base object from the list and recast it to that child class to change its properties. Then we can remove the body from the world or leave it as it is. This gives a really good control for handling collisions of different types of bodies.

BodyTypes:

Static: This type as the name suggests is a static body. It has a 0 mass and it cannot move. Usually ground/walls or stationary enemies can be of this type. Fixture on static bodies can only detect a collision with a fixture on dynamic body.

Kinematic: This is a really useful body type for games, just like 온라인 카지노, which include moving platforms. Kinematic body also has 0 mass but it can be given a velocity and it only detects collision with a fixture of a dynamic body.

Dynamic: This is used for all other types, most of the enemies, bullets etc are dynamic. While creating dynamic bodies its good to give a density to the body and then let box calculate its mass depending on its shape.

This is all for today. Thank you for the patience. Please leave any queries/suggestions/feedback in comments section. We look forward to hearing from you.