Right now I'm still in the planning phase of a my very first game. I'm creating a "Minecraft"-like game in 2D that features blocks that can be destroyed as well as players moving around the map.

For creating the map I chose a 2D-Array of Integers that represent the Block ID. For testing purposes I created a huge map (16348 * 256) and in my prototype that didn't use Box2D everything worked like a charm.

I only rendered those blocks that where within the bounds of my camera and got 60 fps straight. The problem started when I decided to use an existing physics-solution rather than implementing my own one. What I had was basically simple hitboxes around the blocks and then I had to manually check if the player collided with any of those in his neighborhood.

For more advanced physics as well as the collision detection I want to switch over to Box2D. The problem I have right now is ... how to go about the bodies?

I mean, the blocks are of a static bodytype. They don't move on their own, they just are there to be collided with. But as far as I can see it, every block needs his own body with a rectangular fixture attached to it, so as to be destroyable.

But for a huge map such as mine, this turns out to be a real performance bottle-neck. (In fact even a rather small map [compared to the other] of 1024*256 is unplayable.) I mean I create thousands of thousands of blocks. Even if I just render those that are in my immediate neighborhood there are hundreds of them and (at least with the debugRenderer) I drop to 1 fps really quickly (on my own "monster machine").

I thought about strategies like creating just one body, attaching multiple fixtures and only if a fixture got hit, separate it from the body, create a new one and destroy it, but this didn't turn out quite as successful as hoped. (In fact the core just dumps. Ah hello C! I really missed you :X)

Here is the code:

public class Box2DGameScreen implements Screen
{
    private World world;
    private Box2DDebugRenderer debugRenderer;
    private OrthographicCamera camera;

    private final float TIMESTEP = 1 / 60f; // 1/60 of a second -> 1 frame per second
    private final int VELOCITYITERATIONS = 8;
    private final int POSITIONITERATIONS = 3;

    private Map map;
    private BodyDef blockBodyDef;
    private FixtureDef blockFixtureDef;

    private BodyDef groundDef;
    private Body ground;

    private PolygonShape rectangleShape;

    @Override
    public void show()
    {
        world = new World(new Vector2(0, -9.81f), true);
        debugRenderer = new Box2DDebugRenderer();
        camera = new OrthographicCamera();
        // Pixel:Meter = 16:1

        // Body definition
        BodyDef ballDef = new BodyDef();
        ballDef.type = BodyDef.BodyType.DynamicBody;
        ballDef.position.set(0, 1);

        // Fixture definition
        FixtureDef ballFixtureDef = new FixtureDef();
        ballFixtureDef.shape = new CircleShape();
        ballFixtureDef.shape.setRadius(.5f); // 0,5 meter
        ballFixtureDef.restitution = 0.75f; // between 0 (not jumping up at all) and 1 (jumping up the same amount as it fell down)
        ballFixtureDef.density = 2.5f; // kg / m²
        ballFixtureDef.friction = 0.25f; // between 0 (sliding like ice) and 1 (not sliding)

    //    world.createBody(ballDef).createFixture(ballFixtureDef);

        groundDef = new BodyDef();
        groundDef.type = BodyDef.BodyType.StaticBody;
        groundDef.position.set(0, 0);

        ground = world.createBody(groundDef);

        this.map = new Map(20, 20);

        rectangleShape = new PolygonShape();
    //    rectangleShape.setAsBox(1, 1);

        blockFixtureDef = new FixtureDef();
    //    blockFixtureDef.shape = rectangleShape;
        blockFixtureDef.restitution = 0.1f;
        blockFixtureDef.density = 10f;
        blockFixtureDef.friction = 0.9f;
    }

    @Override
    public void render(float delta)
    {
        Gdx.gl.glClearColor(1, 1, 1, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);


        debugRenderer.render(world, camera.combined);
        drawMap();

        world.step(TIMESTEP, VELOCITYITERATIONS, POSITIONITERATIONS);
    }

    private void drawMap()
    {

        for(int a = 0; a < map.getHeight(); a++)
        {
        /*
            if(camera.position.y - (camera.viewportHeight/2) > a)
                continue;

            if(camera.position.y - (camera.viewportHeight/2) < a)
                break;
        */
            for(int b = 0; b < map.getWidth(); b++)
            {
            /*    if(camera.position.x - (camera.viewportWidth/2) > b)
                    continue;

                if(camera.position.x - (camera.viewportWidth/2) < b)
                    break;
            */
            /*
                blockBodyDef = new BodyDef();
                blockBodyDef.type = BodyDef.BodyType.StaticBody;
                blockBodyDef.position.set(b, a);

                world.createBody(blockBodyDef).createFixture(blockFixtureDef);
            */
                PolygonShape rectangleShape = new PolygonShape();
                rectangleShape.setAsBox(1, 1, new Vector2(b, a), 0);

                blockFixtureDef.shape = rectangleShape;

                ground.createFixture(blockFixtureDef);
                rectangleShape.dispose();

            }
        }
    }

    @Override
    public void resize(int width, int height)
    {
        camera.viewportWidth = width / 16;
        camera.viewportHeight = height / 16;
        camera.update();
    }

    @Override
    public void hide() {
        dispose();
    }

    @Override
    public void pause() {

    }

    @Override
    public void resume() {

    }

    @Override
    public void dispose() {
        world.dispose();
        debugRenderer.dispose();
    }
}

As you can see I'm facing multiple problems here. I'm not quite sure how to check for the bounds but also if the map is bigger than 24*24 like 1024*256 Java just crashes -.-. And with 24*24 I get like 9 fps. So I'm doing something really terrible here, it seems and I assume that there most be a (much more performant) way, even with Box2D's awesome physics.

Any other ideas?

Thanks in advance!