steel_core/world/

world_entities.rs

//! This module contains the implementation of the world's entity-related methods.
use std::{ptr, sync::Arc};

use steel_protocol::packets::game::{CGameEvent, GameEventType};
use steel_registry::{vanilla_custom_stats, vanilla_entities};
use steel_utils::ChunkPos;

use crate::{
    entity::{
        AddEntityError, Entity, EntityOwnership, LivingEntity, NullEntityCallback,
        PlayerEntityCallback, RemovalReason, SharedEntity,
    },
    player::connection::NetworkConnection,
    player::player_data::PersistentPlayerData,
    player::player_inventory::MenuRemovalStatus,
    player::{DomainResidenceToken, Player, ResetReason},
    world::World,
};

impl World {
    /// Returns whether this exact player is registered in this world.
    #[must_use]
    pub(crate) fn contains_player(&self, player: &Player) -> bool {
        self.players
            .get_by_entity_id(player.id())
            .is_some_and(|registered| ptr::eq(registered.as_ref(), player))
    }

    fn loaded_world_memberships(player: &Arc<Player>) -> Vec<Arc<World>> {
        player.server.upgrade().map_or_else(Vec::new, |server| {
            server
                .worlds
                .values()
                .filter(|world| world.contains_player(player))
                .cloned()
                .collect()
        })
    }

    fn reject_duplicate_player_membership(
        player: &Arc<Player>,
        target_world: &Arc<World>,
        operation: &str,
    ) -> bool {
        let mut memberships = Self::loaded_world_memberships(player);
        if target_world.contains_player(player)
            && !memberships
                .iter()
                .any(|world| Arc::ptr_eq(world, target_world))
        {
            memberships.push(Arc::clone(target_world));
        }
        if memberships.is_empty() {
            return false;
        }

        tracing::error!(
            player = %player.gameprofile.name,
            target_world = %target_world.key,
            membership_count = memberships.len(),
            operation,
            "Refusing to register a player that already belongs to a loaded world"
        );
        player.connection.close();
        for world in memberships {
            world.remove_player_for_world_change(player);
        }
        true
    }

    fn take_player_for_removal(&self, player: &Arc<Player>) -> Option<Arc<Player>> {
        if !self.contains_player(player) {
            return None;
        }
        self.chunk_map.remove_player(player);
        self.players.remove_player_sync(player)
    }

    fn attach_player_entity_callback(self: &Arc<Self>, player: &Arc<Player>) {
        let callback = Arc::new(PlayerEntityCallback::new(player.id(), Arc::downgrade(self)));
        player.set_level_callback(callback);
    }

    fn try_register_player_entity(
        self: &Arc<Self>,
        player: &Arc<Player>,
    ) -> Result<(), AddEntityError> {
        let entity: SharedEntity = Arc::<Player>::clone(player);
        let lifecycle = self
            .entity_manager()
            .add_live_entity(entity, EntityOwnership::External)?;
        self.attach_player_entity_callback(player);
        self.apply_entity_lifecycle_changes(lifecycle);
        Ok(())
    }

    fn register_player_entity(self: &Arc<Self>, player: &Arc<Player>) {
        if let Err(error) = self.try_register_player_entity(player) {
            panic!("failed to register player entity: {error}");
        }
    }

    fn unride_player_for_removal(&self, player: &Player, store_root_vehicle: bool) {
        for passenger in player.passengers() {
            passenger.stop_riding();
            self.mark_chunk_dirty(ChunkPos::from_entity_pos(passenger.position()));
        }

        if store_root_vehicle
            && let Some(root_vehicle) = player.root_vehicle()
            && root_vehicle.id() != player.id()
            && root_vehicle.has_exactly_one_player_passenger()
        {
            Self::remove_root_vehicle_tree_stored_with_player(root_vehicle);
            return;
        }

        if let Some(vehicle) = player.vehicle() {
            player.stop_riding();
            self.mark_chunk_dirty(ChunkPos::from_entity_pos(vehicle.position()));
        }
    }

    fn remove_root_vehicle_tree_stored_with_player(entity: SharedEntity) {
        let passengers = entity.passengers();
        entity.set_removed(RemovalReason::StoredWithPlayer);

        for passenger in passengers {
            if passenger.entity_type() == &vanilla_entities::PLAYER {
                continue;
            }
            Self::remove_root_vehicle_tree_stored_with_player(passenger);
        }
    }

    pub(crate) fn unregister_player_entity(&self, player: &Player) {
        let entity_id = player.id();
        self.remove_entity_from_tracker(entity_id);

        self.entity_manager()
            .remove_live_entity(entity_id, RemovalReason::ChangedWorld);
        player.set_level_callback(Arc::new(NullEntityCallback));
    }

    pub(crate) fn register_respawned_player_entity(self: &Arc<Self>, player: &Arc<Player>) {
        self.register_player_entity(player);
        self.chunk_map.update_player_status(player);
    }

    /// Installs a fresh player incarnation in this world's live indexes.
    ///
    /// Same-world respawns provide the exact detached old map occupant. Cross-world
    /// and End-credits respawns insert into an empty target-world player map.
    pub(crate) fn install_respawned_player(
        self: &Arc<Self>,
        player: Arc<Player>,
        expected_old_player: Option<&Arc<Player>>,
    ) -> bool {
        let installed = if let Some(expected_old_player) = expected_old_player {
            self.players
                .replace_player(expected_old_player, Arc::clone(&player))
        } else {
            self.players.insert(Arc::clone(&player))
        };
        if !installed {
            return false;
        }

        if let Err(error) = self.try_register_player_entity(&player) {
            let rolled_back = if let Some(expected_old_player) = expected_old_player {
                self.players
                    .replace_player(&player, Arc::clone(expected_old_player))
            } else {
                self.players.remove_player_sync(&player).is_some()
            };
            if !rolled_back {
                tracing::error!(
                    player = %player.gameprofile.name,
                    world = %self.key,
                    "Respawn entity registration failed after world player ownership changed"
                );
            }
            tracing::warn!(
                player = %player.gameprofile.name,
                world = %self.key,
                "Refusing to install respawned player entity: {error}"
            );
            return false;
        }

        self.chunk_map.update_player_status(&player);
        self.update_sleeping_player_list();
        player.send_packet(CGameEvent {
            event: GameEventType::LevelChunksLoadStart,
            data: 0.0,
        });
        true
    }

    pub(crate) fn add_respawned_player(self: &Arc<Self>, player: Arc<Player>) -> bool {
        self.install_respawned_player(player, None)
    }

    /// Detaches a disconnecting player from live world state and snapshots it.
    ///
    /// Persistence happens asynchronously after the server's pre-tick phase completes.
    pub(crate) fn detach_player_for_disconnect(
        self: &Arc<Self>,
        player: Arc<Player>,
    ) -> (Arc<Player>, String, PersistentPlayerData) {
        assert_eq!(
            player.remove_all_menus(),
            MenuRemovalStatus::Complete,
            "disconnect menu removal must run at the packet-processing safe point"
        );

        player.award_custom_stat(&vanilla_custom_stats::LEAVE_GAME);
        let Some(player) = self.take_player_for_removal(&player) else {
            // End credits and failed target admission deliberately have no live
            // world membership but still need one authoritative disconnect save.
            let domain = self.domain().to_owned();
            let player_data = PersistentPlayerData::from_player(&player);
            player.store_ender_pearls_with_player();
            return (player, domain, player_data);
        };
        let domain = self.domain().to_owned();
        if player.is_sleeping() {
            player.stop_sleep_in_bed(true, false);
        }
        let player_data = PersistentPlayerData::from_player(&player);

        self.unride_player_for_removal(&player, true);
        player.store_ender_pearls_with_player();
        self.unregister_player_entity(&player);

        // Remove player from entity tracking (stop tracking all entities for this player)
        self.entity_tracker().on_player_leave(&player);

        self.player_area_map.on_player_leave(&player);
        (player, domain, player_data)
    }

    /// Removes a player from the world during a world change.
    ///
    /// Unlike `remove_player`, this is synchronous and skips player data saving and tab list
    /// removal — the player stays in the global tab list since they are only switching worlds.
    pub(crate) fn remove_player_for_world_change(self: &Arc<Self>, player: &Arc<Player>) {
        let Some(player) = self.take_player_for_removal(player) else {
            return;
        };
        player.award_custom_stat(&vanilla_custom_stats::LEAVE_GAME);
        self.unride_player_for_removal(&player, false);
        self.unregister_player_entity(&player);
        self.entity_tracker().on_player_leave(&player);
        self.player_area_map.on_player_leave(&player);
        // Note: no CRemovePlayerInfo — player stays in the global tab list
    }

    /// Detaches the exact old player incarnation for a fresh-player respawn.
    ///
    /// Same-world respawns retain the old player-map entry so installation can
    /// compare-and-swap it with the fresh player. Cross-world respawns remove it.
    /// This does not award `LEAVE_GAME` or snapshot persistent player data.
    pub(crate) fn detach_player_for_respawn(
        self: &Arc<Self>,
        player: &Arc<Player>,
        retain_player_map_entry: bool,
    ) -> bool {
        if !self.contains_player(player) {
            return false;
        }
        if player.is_sleeping() {
            player.stop_sleep_in_bed(true, false);
        }

        let detached_player = if retain_player_map_entry {
            Arc::clone(player)
        } else {
            let Some(detached_player) = self.players.remove_player_sync(player) else {
                return false;
            };
            detached_player
        };

        self.chunk_map.remove_player(&detached_player);
        self.unride_player_for_removal(&detached_player, false);
        self.unregister_player_entity(&detached_player);
        self.entity_tracker().on_player_leave(&detached_player);
        self.player_area_map.on_player_leave(&detached_player);
        self.update_sleeping_player_list();
        true
    }

    /// Removes an exact fresh respawn installation during transaction cleanup.
    ///
    /// A stale cleanup request cannot detach a newer player incarnation with the
    /// same UUID and numeric entity ID.
    pub(crate) fn remove_respawned_player(self: &Arc<Self>, player: &Arc<Player>) -> bool {
        self.detach_player_for_respawn(player, false)
    }

    /// Detaches a player for a domain switch and returns its persistence snapshot.
    pub(crate) fn detach_player_for_domain_switch(
        self: &Arc<Self>,
        player: &Arc<Player>,
    ) -> Option<(PersistentPlayerData, DomainResidenceToken)> {
        let player = self.take_player_for_removal(player)?;

        player.award_custom_stat(&vanilla_custom_stats::LEAVE_GAME);
        let player_data = PersistentPlayerData::from_player(&player);

        self.unride_player_for_removal(&player, true);
        player.store_ender_pearls_with_player();
        self.unregister_player_entity(&player);
        self.entity_tracker().on_player_leave(&player);
        self.player_area_map.on_player_leave(&player);
        let residence_token = player.advance_domain_residence();
        Some((player_data, residence_token))
    }

    /// Adds a player to the world.
    ///
    /// On `InitialJoin`, sends full tab list + entity spawn synchronization to/from all
    /// players. On `WorldChange`, this is skipped — the player already exists in all
    /// clients' tab lists and the entity tracker handles spawning as chunks load.
    #[must_use]
    pub(crate) fn add_player(self: &Arc<Self>, player: Arc<Player>, _reason: ResetReason) -> bool {
        if Self::reject_duplicate_player_membership(&player, self, "world change") {
            return false;
        }
        if !self.players.insert(player.clone()) {
            player.connection.close();
            return false;
        }

        self.register_player_entity(&player);
        self.chunk_map.update_player_status(&player);
        self.update_sleeping_player_list();

        player.send_packet(CGameEvent {
            event: GameEventType::LevelChunksLoadStart,
            data: 0.0,
        });

        true
    }
}