are blocks always available? or should I wait for them to be loaded (from the server)

[folkertvanheusden]

E.g. this worked once (a bit; half of the blocks did not appear) but since then every getBlock() returns NULL:

        auto entity_manager = GetEntityManager();
        auto local_player = entity_manager->GetLocalPlayer();

        Vector3<double> pp;

        do {
                usleep(101000);
                std::lock_guard<std::mutex> player_guard(local_player->GetMutex());
                pp = local_player->GetPosition();
        }
        while(pp.y == 0.);

        printf("%.2f,%.2f,%.2f\n", pp.x, pp.y, pp.z);

        for(int z=pp.z - 50; z<pp.z + 50; z++) {
                for(int y=std::max(0., pp.y-50); y<pp.y+50; y++) {
                        for(int x=pp.x-50; x<pp.x+50; x++) {
                                Position v { x, y, z };

                                std::lock_guard<std::mutex> world_guard(world->GetMutex());

                                const Block *block = world->GetBlock(v);

                                if (!block) {
                                        usleep(1000);
                                        continue;
                                }

                                printf("%d,%d,%d %s\n", x, y, z, block->GetBlockstate()->GetName().c_str());
                        }
                }
        }

[adepierre]

Only loaded blocks are available, if you get null it's probably that they're not loaded yet.

However, I can see in your code that your world_guard lockking the world mutex is in the same scope than your sleep. So you wait for more blocks to be loaded but you also block (pun not intended) any chunk data to be loaded in the world during this time.

A simple thing you could do is something like that (you could add a while loop to be sure you get all blocks):

std::shared_ptr<Blockstate> blockstate;
{
    std::lock_guard<std::mutex> world_guard(world->GetMutex());

    const Block *block = world->GetBlock(v);

    if (block) 
    {
        blockstate = block->GetBlockstate();
    }
}

if (!blockstate)
{
    // sleep without keeping the world locked
}

PS : if you're not familiar with world_guard, basically they keep locking the associated mutex until they get destroyed, hence the additional curly brackets to create a limited scope for it.

[folkertvanheusden]

Makes a lot of sense. Program now works!