a basic 3d example

[stillonearth]

I'm trying to add a bunch of cubes that should interact

fn spawn_game_world(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // Plane

    let maps = map_parser::load_maps("shareware/MAPHEAD.WL1", "shareware/GAMEMAPS.WL1", Some(1));

    let map = &maps[0];

    let size = map.width_n_tiles * map.height_n_tiles;

    let mesh = meshes.add(Mesh::from(shape::Plane {
        size: (size as f32),
    }));

    let bundle = PbrBundle {
        mesh: mesh.clone(),
        material: materials.add(Color::WHITE.into()),
        ..Default::default()
    };

    commands
        .spawn_bundle(bundle)
        .insert(RigidBody::Static)
        .insert(
            CollisionLayers::none()
                .with_group(Layer::World)
                .with_mask(Layer::World),
        )
        .with_children(|p| {
            let plane = map.plane0.as_ref().unwrap();

            // Cubes as walls
            plane
                .chunks_exact(2)
                .map(|word| u16::from_le_bytes(word.try_into().unwrap()))
                .enumerate()
                .for_each(|(word_i, word)| {
                    let x = word_i % usize::from(map.width_n_tiles) * 2;
                    let z = word_i / usize::from(map.height_n_tiles) * 2;
                    let y = 5.0 as usize;

                    if word == 90 {
                    } else if word == 91 {
                    } else if word < 107 {
                        p.spawn_bundle(PbrBundle {
                            mesh: meshes.add(Mesh::from(shape::Cube { size: 2.0 })),
                            material: materials.add(Color::BLACK.into()),
                            transform: Transform::from_translation(Vec3::new(
                                x as f32, y as f32, z as f32,
                            )),
                            ..Default::default()
                        })
                        .insert(GlobalTransform::default())
                        .insert(RigidBody::Dynamic)
                        .insert(
                            CollisionLayers::none()
                                .with_group(Layer::World)
                                .with_mask(Layer::World),
                        )
                        .insert(CollisionShape::Cuboid {
                            half_extends: Vec3::new(1.0, 1.0, 1.0),
                            border_radius: None,
                        });
                        // .insert(CollisionShape::Sphere { radius: 2.0 });
                    } else {
                    }
                });
        });
}

In this example cubes fall through a plane while should collide with it and stay in place.

[jcornaz]

The ground plane is missing a collision shape. For your use case, a cuboid should be fine.