Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Absorption #557

Closed
SelfMadeSystem opened this issue Oct 12, 2023 · 0 comments
Closed

Absorption #557

SelfMadeSystem opened this issue Oct 12, 2023 · 0 comments
Labels
enhancement New feature or request

Comments

@SelfMadeSystem
Copy link
Contributor

SelfMadeSystem commented Oct 12, 2023 •
edited
Loading

Describe the problem related to your feature request.

Absorption for the player is already somewhat implemented (see AbsorptionAmount), but:

  1. we need a way to damage the player w/ absorption (see Damaging entities + death #556 for damaging)
  2. ALL living entities should have absorption, not just the player

What solution would you like?

A full and proper implementation of absorption. Damaging the absorption should be properly dealt with by #556

What alternative(s) have you considered?

Just continuing using AbsorptionAmount, but that only works for players.

Additional context

Required for properly damaging entities with absorption (see #556) and for potions (see #558)

See net.minecraft.entity.LivingEntity#absorptionAmount
@SelfMadeSystem SelfMadeSystem added the enhancement New feature or request label Oct 12, 2023
This was referenced Oct 12, 2023
Open
Merged
Merged
dyc3 added a commit that referenced this issue Oct 13, 2023
@SelfMadeSystem @dyc3
Absorption (#563)
498f7a5 
# Problem

See #557

Will be necessary to implement #556 and #558

# Objective

Implement absorption for ALL living entities.

# Solution

Make a special case for LivingEntity for Absorption since it's
untracked.

# Playground

<details>
<summary>Playground</summary>

```rs
use valence::client::despawn_disconnected_clients;
use valence::entity::living::Absorption;
use valence::log::LogPlugin;
use valence::network::ConnectionMode;
use valence::prelude::*;

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

const SPAWN_Y: i32 = 64;

pub fn build_app(app: &mut App) {
    app.insert_resource(NetworkSettings {
        connection_mode: ConnectionMode::Offline,
        ..Default::default()
    })
    .add_plugins(DefaultPlugins.build().disable::<LogPlugin>())
    .add_systems(Startup, setup)
    .add_systems(EventLoopUpdate, toggle_absorption_on_sneak)
    .add_systems(Update, (init_clients, despawn_disconnected_clients))
    .run();
}

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

    for z in -5..5 {
        for x in -5..5 {
            layer.chunk.insert_chunk([x, z], UnloadedChunk::new());
        }
    }

    for z in -25..25 {
        for x in -25..25 {
            layer
                .chunk
                .set_block([x, SPAWN_Y, z], BlockState::GRASS_BLOCK);
        }
    }

    commands.spawn(layer);
}

fn init_clients(
    mut clients: Query<
        (
            &mut EntityLayerId,
            &mut VisibleChunkLayer,
            &mut VisibleEntityLayers,
            &mut Position,
            &mut GameMode,
        ),
        Added<Client>,
    >,
    layers: Query<Entity, (With<ChunkLayer>, With<EntityLayer>)>,
) {
    for (
        mut layer_id,
        mut visible_chunk_layer,
        mut visible_entity_layers,
        mut pos,
        mut game_mode,
    ) in &mut clients
    {
        let layer = layers.single();

        layer_id.0 = layer;
        visible_chunk_layer.0 = layer;
        visible_entity_layers.0.insert(layer);
        pos.set([0.0, SPAWN_Y as f64 + 1.0, 0.0]);
        *game_mode = GameMode::Survival;
    }
}

pub fn toggle_absorption_on_sneak(
    mut clients: Query<&mut Absorption>,
    mut events: EventReader<SneakEvent>,
) {
    for event in events.iter() {
        if event.state == SneakState::Start {
            if let Ok(mut absorption) = clients.get_mut(event.client) {
                absorption.0 = if absorption.0 == 0.0 { 4.0 } else { 0.0 };
            }
        }
    }
}
```
</details>

---------

Co-authored-by: Carson McManus <[email protected]>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
enhancement New feature or request
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@SelfMadeSystem