Visibility layers for Minecraft Entities

[Bafbi]

Ref

#342

Description

I use the word 'mob' to reference minecraft entities and client for the player.

Implementation of a layer system for mob, the client can have a ClientLayerMask component which determine for what layer he can see mobs. The mobs them can have a Layer component which determine on what layer they are.

Implementation

• Client see only update for mask layer
• Spawn or Sync mob status when arriving on a new layer
• Despawn mob when quitting a layer
• Don't spawn in not in visible layer at connection
• Having the possibility to have infinite numbers of layers

Potential Upgrade

• Not have one buffer per layer
• Extend layers to particle and other
• Make the layer component be able to have the ref of an client to not use a layer per client when we just need to sned to one player

Playground

code

use std::f64::consts::TAU;

use glam::{DQuat, EulerRot};
use valence::client::despawn_disconnected_clients;
use valence::client::layer::ClientLayerSet;
use valence::client::message::ChatMessageEvent;
use valence::entity::Layer;
use valence::nbt::compound;
use valence::network::ConnectionMode;
use valence::prelude::*;

#[allow(unused_imports)]
use crate::extras::*;

type SpherePartBundle = valence::entity::cow::CowEntityBundle;

const SPHERE_CENTER: DVec3 = DVec3::new(8.0, SPAWN_POS.y as f64 + 2.0, 8.0);
const SPHERE_AMOUNT: usize = 200;
const SPHERE_MIN_RADIUS: f64 = 6.0;
const SPHERE_MAX_RADIUS: f64 = 12.0;
const SPHERE_FREQ: f64 = 0.5;

const SPAWN_POS: BlockPos = BlockPos::new(8, 100, 8);

/// Marker component for entities that are part of the sphere.
#[derive(Component)]
struct SpherePart;

pub fn build_app(app: &mut App) {
    app.insert_resource(NetworkSettings {
        connection_mode: ConnectionMode::Offline,
        ..Default::default()
    })
    .add_plugins(DefaultPlugins)
    .add_startup_system(setup)
    .add_system(init_clients)
    .add_system(update_sphere)
    .add_system(set_layer)
    .add_system(despawn_disconnected_clients)
    .add_system(toggle_gamemode_on_sneak.in_schedule(EventLoopSchedule));
}

fn setup(
    mut commands: Commands,
    server: Res<Server>,
    biomes: Res<BiomeRegistry>,
    dimensions: Res<DimensionTypeRegistry>,
) {
    let mut instance = Instance::new(ident!("overworld"), &dimensions, &biomes, &server);

    for z in -5..5 {
        for x in -5..5 {
            instance.insert_chunk([x, z], Chunk::default());
        }
    }

    for z in 2..14 {
        for x in 2..14 {
            instance.set_block([x, SPAWN_POS.y, z], BlockState::GLASS);
        }
    }

    instance.set_block(
        [SPAWN_POS.x, SPAWN_POS.y + 1, SPAWN_POS.z],
        Block::with_nbt(
            BlockState::OAK_SIGN.set(PropName::Rotation, PropValue::_1),
            compound! {
                "Text1" => "Set your layers".into_text(),
                "Text2" => "in chat, send => 0 1 2".into_text(),
                "Text3" => "set your layers to 0, 1, 2".color(Color::GREEN),
            },
        ),
    );
    instance.set_block(
        [SPAWN_POS.x + 1, SPAWN_POS.y + 1, SPAWN_POS.z],
        Block::with_nbt(
            BlockState::OAK_SIGN.set(PropName::Rotation, PropValue::_4),
            compound! {
                "Text1" => "Type in chat:".color(Color::RED),
            },
        ),
    );

    let instance_id = commands.spawn(instance).id();

    let mut i = 0;
    commands.spawn_batch([0; SPHERE_AMOUNT].map(|_| {
        i += 1;
        (
            SpherePartBundle {
                location: Location(instance_id),
                ..Default::default()
            },
            SpherePart,
            Layer(i % (SPHERE_AMOUNT / 50) as u8),
        )
    }));
}

fn init_clients(
    mut commands: Commands,
    mut clients: Query<(Entity, &mut Location, &mut Position, &mut GameMode), Added<Client>>,
    instances: Query<Entity, With<Instance>>,
) {
    for (entity, mut loc, mut pos, mut gamemode) in clients.iter_mut() {
        loc.0 = instances.single();
        pos.set(SPHERE_CENTER);
        *gamemode = GameMode::Creative;
        commands.entity(entity).insert(ClientLayerSet::new(vec![0]));
    }
}

fn set_layer(
    mut clients: Query<(&mut ClientLayerSet, &mut Client)>,
    mut chat_message_event: EventReader<ChatMessageEvent>,
) {
    for event in chat_message_event.iter() {
        // Split the message into individual words
        let words: Vec<&str> = event.message.split_whitespace().collect();

        // Parse each word into a layer number
        let layers: Vec<usize> = words.iter().filter_map(|word| word.parse().ok()).collect();

        if let Ok((mut layer_set, mut client)) = clients.get_mut(event.client) {
            layer_set.clear();
            // Toggle true each layer in the set
            for layer in layers {
                layer_set.set(layer as u8, true);
            }

            // Update the client's action bar with the new layer set
            client.set_action_bar(format!("Layers: {:?}", layer_set).into_text());
        }
    }
}

fn update_sphere(
    settings: Res<CoreSettings>,
    server: Res<Server>,
    mut parts: Query<(&mut Position, &mut Look, &mut HeadYaw), With<SpherePart>>,
) {
    let time = server.current_tick() as f64 / settings.tick_rate.get() as f64;

    let rot_angles = DVec3::new(0.2, 0.4, 0.6) * SPHERE_FREQ * time * TAU % TAU;
    let rot = DQuat::from_euler(EulerRot::XYZ, rot_angles.x, rot_angles.y, rot_angles.z);

    let radius = lerp(
        SPHERE_MIN_RADIUS,
        SPHERE_MAX_RADIUS,
        ((time * SPHERE_FREQ * TAU).sin() + 1.0) / 2.0,
    );

    for ((mut pos, mut look, mut head_yaw), p) in
        parts.iter_mut().zip(fibonacci_spiral(SPHERE_AMOUNT))
    {
        debug_assert!(p.is_normalized());

        let dir = rot * p;

        pos.0 = SPHERE_CENTER + dir * radius;
        look.set_vec(dir.as_vec3());
        head_yaw.0 = look.yaw;
    }
}

/// Distributes N points on the surface of a unit sphere.
fn fibonacci_spiral(n: usize) -> impl Iterator<Item = DVec3> {
    let golden_ratio = (1.0 + 5_f64.sqrt()) / 2.0;

    (0..n).map(move |i| {
        // Map to unit square
        let x = i as f64 / golden_ratio % 1.0;
        let y = i as f64 / n as f64;

        // Map from unit square to unit sphere.
        let theta = x * TAU;
        let phi = (1.0 - 2.0 * y).acos();
        DVec3::new(theta.cos() * phi.sin(), theta.sin() * phi.sin(), phi.cos())
    })
}

fn lerp(a: f64, b: f64, t: f64) -> f64 {
    a * (1.0 - t) + b * t
}

[dyc3]

I'd like to see some unit tests for this.

[rj00a]

Currently working on a redesign of Instances and Chunks to fix a number of issues. I'd like to finish my redesign before taking a closer look at this, since it may have a large impact on the approach taken here. It should be finished in the next day or two.

[tachibanayui]

Currently working on a redesign of Instances and Chunks to fix a number of issues. I'd like to finish my redesign before taking a closer look at this, since it may have a large impact on the approach taken here. It should be finished in the next day or two.

Visibility Layers will impact a lot of features IMO. I think we should take our time and make it right the first time or it gonna be expensive to fix later.

[tachibanayui]

Nice work on implementing Visibility Layers. I have a few suggestions and design choices to consider.

[tachibanayui]

Should an Entity be on multiple layers? It could be useful for interactions between different entities such as collisions, ai behaviors, hit-scanning

[Bafbi]

I don't really know for this one, cause the use of the layer is primarily for visibility, and having entity on multiple layer pose question like if the entity and client have two layers in common, what append ?
I think that maybe we can rename this one visibility layer and there could be other layer types for collisions and ai.
But even that I don't really see the use case ngl.

[rj00a]

Finished the chunk/instance redesign in #402. Let me know if you have any issues.

[rj00a]

Here's my take on visibility layers: #424.