steel_core/behavior/blocks/decoration/

sign_block.rs

//! Sign block behavior implementation.
//!
//! Handles sign placement and block entity creation for all sign types.

use std::cmp::Ordering;
use std::sync::{Arc, Weak};

use steel_macros::block_behavior;
use steel_math::{
    DEGREE_90, DEGREE_180, RAD_TO_DEG_F64, convert_to_rotation_segment, wrap_degrees,
};
use steel_protocol::packets::game::SoundSource;
use steel_registry::REGISTRY;
use steel_registry::block_entity_type::BlockEntityTypeRef;
use steel_registry::blocks::BlockRef;
use steel_registry::blocks::block_state_ext::BlockStateExt;
use steel_registry::blocks::properties::{
    BlockStateProperties, BoolProperty, Direction, EnumProperty, IntProperty,
};
use steel_registry::blocks::shapes::SupportType;
use steel_registry::{
    stat::vanilla_stat_types, vanilla_block_entity_types, vanilla_blocks, vanilla_game_events,
};
use steel_utils::{
    BlockPos, BlockStateId, Downcast as _,
    types::{InteractionHand, SignTextSlot},
};

use crate::behavior::block::{
    BlockBehavior, BlockEntityCreation, schedule_water_tick_if_waterlogged,
};
use crate::behavior::context::{BlockHitResult, BlockPlaceContext, InteractionResult};
use crate::behavior::{ITEM_BEHAVIORS, InventoryAccess, PlacementSource};
use crate::block_entity::{BlockEntity, BlockEntityTicker, entities::SignBlockEntity};
use crate::entity::Entity;
use crate::player::Player;
use crate::world::{LevelReader, ScheduledTickAccess, World, game_event::GameEventContext};

/// Gets the nearest looking directions from the player's rotation.
///
/// Returns horizontal directions in order of how closely they match the player's look direction.
fn get_nearest_looking_directions(rotation: f32, clicked_face: Direction) -> Vec<Direction> {
    // Build list of directions in order of preference
    // Start with the opposite of the clicked face (most natural for wall signs)
    // Then add directions based on player facing
    let mut directions = Vec::with_capacity(4);

    // Add horizontal directions in order of how closely they match player's look
    let all_horizontal = [
        Direction::North,
        Direction::East,
        Direction::South,
        Direction::West,
    ];

    // Calculate angle for each direction and sort by distance to player's rotation
    let mut scored: Vec<(Direction, f32)> = all_horizontal
        .iter()
        .map(|&dir| {
            let dir_angle = dir.to_yaw();
            (dir, wrap_degrees(rotation - dir_angle).abs())
        })
        .collect();

    scored.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(Ordering::Equal));

    for (dir, _) in scored {
        directions.push(dir);
    }

    // If clicked face is horizontal, prefer placing on the opposite side
    if clicked_face.is_horizontal() {
        let opposite = clicked_face.opposite();
        if let Some(pos) = directions.iter().position(|&d| d == opposite) {
            directions.remove(pos);
            directions.insert(0, opposite);
        }
    }

    directions
}

/// Calculates which side of a sign the player is facing.
///
/// Uses the sign's rotation (from block state) and the player's position
/// relative to the sign to determine which side they're looking at.
pub fn facing_text_slot(state: BlockStateId, pos: BlockPos, player: &Player) -> SignTextSlot {
    // Get the sign's Y rotation in degrees from the block state
    let sign_y_rot = get_sign_rotation_degrees(state);

    // Calculate player's angle relative to the sign center
    let player_pos = player.position();
    let dx = player_pos.x - (f64::from(pos.0.x) + 0.5);
    let dz = player_pos.z - (f64::from(pos.0.z) + 0.5);

    // Calculate angle from sign to player (in degrees, -90 to account for Minecraft's coordinate system)
    let player_angle = (dz.atan2(dx) * RAD_TO_DEG_F64) as f32 - DEGREE_90;

    // Front text if the angle difference is <= 90 degrees
    if wrap_degrees(player_angle - sign_y_rot).abs() <= DEGREE_90 {
        SignTextSlot::Front
    } else {
        SignTextSlot::Back
    }
}

/// Gets the Y rotation of a sign in degrees from its block state.
fn get_sign_rotation_degrees(state: BlockStateId) -> f32 {
    // Standing signs use "rotation" property (0-15, each step is 22.5 degrees)
    if let Some(rotation) = state.try_get_value(ROTATION_16) {
        return f32::from(rotation) * 22.5;
    }

    // Wall signs use "facing" property
    if let Some(facing) = state.try_get_value(HORIZONTAL_FACING) {
        return facing.to_yaw();
    }

    0.0
}

/// Checks if a block state can support a standing sign.
///
/// Vanilla uses `isSolid()` which checks if the collision shape is a full cube.
/// This means signs cannot be placed on other signs, fences, walls, etc.
fn can_support_standing_sign(world: &(impl LevelReader + ?Sized), pos: BlockPos) -> bool {
    let below_pos = BlockPos::new(pos.x(), pos.y() - 1, pos.z());
    let below_state = world.get_block_state(below_pos);
    below_state.is_solid()
}

/// Checks if a wall sign can survive at the given position with the given facing.
///
/// Vanilla uses `isSolid()` which allows wall signs to be placed on other signs
/// (since signs have `forceSolidOn`).
fn can_wall_sign_survive(
    world: &(impl LevelReader + ?Sized),
    pos: BlockPos,
    facing: Direction,
) -> bool {
    // Wall sign needs a solid block behind it
    let behind_pos = facing.opposite().relative(pos);
    let behind_state = world.get_block_state(behind_pos);
    behind_state.is_solid()
}

/// Checks if a ceiling hanging sign can survive at the given position.
fn can_ceiling_hanging_sign_survive(world: &(impl LevelReader + ?Sized), pos: BlockPos) -> bool {
    let above_pos = BlockPos::new(pos.x(), pos.y() + 1, pos.z());
    let above_state = world.get_block_state(above_pos);
    world.is_face_sturdy_for(above_state, above_pos, Direction::Down, SupportType::Center)
}

/// Checks if a wall hanging sign can attach to a neighboring block.
///
/// Vanilla's `WallHangingSignBlock.canAttachTo` checks:
/// 1. If the neighbor is a wall hanging sign on the same axis, allow attachment
/// 2. Otherwise, check if the face is sturdy with FULL support type
fn can_attach_to(
    world: &(impl LevelReader + ?Sized),
    sign_facing: Direction,
    attach_pos: BlockPos,
    attach_face: Direction,
) -> bool {
    let attach_state = world.get_block_state(attach_pos);
    let attach_block = REGISTRY.blocks.by_state_id(attach_state);

    // Check if it's another wall hanging sign (vanilla uses BlockTags.WALL_HANGING_SIGNS)
    if let Some(block) = attach_block
        && block.key.path.contains("wall_hanging_sign")
    {
        // Wall hanging signs can chain if they're on the same axis
        if let Some(neighbor_facing) = attach_state.try_get_value(HORIZONTAL_FACING) {
            return neighbor_facing.axis() == sign_facing.axis();
        }
    }

    // Otherwise, check for sturdy face with FULL support
    world.is_face_sturdy_for(attach_state, attach_pos, attach_face, SupportType::Full)
}

/// Checks if a wall hanging sign can survive at the given position.
///
/// Wall hanging signs need support on at least one side perpendicular to facing.
/// This matches vanilla's `WallHangingSignBlock.canPlace`.
fn can_wall_hanging_sign_survive(
    world: &(impl LevelReader + ?Sized),
    pos: BlockPos,
    facing: Direction,
) -> bool {
    let clockwise = facing.rotate_y_clockwise();
    let counter_clockwise = facing.rotate_y_counter_clockwise();

    let can_attach_clockwise = {
        let attach_pos = clockwise.relative(pos);
        can_attach_to(world, facing, attach_pos, counter_clockwise)
    };

    let can_attach_counter = {
        let attach_pos = counter_clockwise.relative(pos);
        can_attach_to(world, facing, attach_pos, clockwise)
    };

    can_attach_clockwise || can_attach_counter
}

fn try_apply_sign_item(
    state: BlockStateId,
    world: &Arc<World>,
    pos: BlockPos,
    player: &Player,
    inv: &mut InventoryAccess,
) -> InteractionResult {
    let Some(block_entity) = world.get_block_entity(pos) else {
        return InteractionResult::Pass;
    };
    let Some(sign) = block_entity.downcast_ref::<SignBlockEntity>() else {
        return InteractionResult::Pass;
    };

    // Keep the inventory unlocked while an applicator changes the world.
    let stack = inv.with_item(|item| item.clone());
    let behavior = ITEM_BEHAVIORS.get_behavior(stack.item());
    let Some(applicator) = behavior.as_sign_applicator() else {
        return InteractionResult::TryEmptyHandInteraction;
    };
    if !player.abilities.lock().may_build
        || sign.is_waxed()
        || sign.is_other_player_editing(player.gameprofile.id())
    {
        return InteractionResult::TryEmptyHandInteraction;
    }

    let slot = facing_text_slot(state, pos, player);
    if !applicator.can_apply_to_sign(&sign.get_text(slot), &stack, player)
        || !applicator.try_apply_to_sign(world, sign, slot, &stack, player)
    {
        return InteractionResult::TryEmptyHandInteraction;
    }

    sign.set_changed();
    if let Some(nbt) = sign.get_update_tag() {
        world.broadcast_block_entity_update(pos, sign.get_type(), nbt);
    }
    player.award_stat(&vanilla_stat_types::ITEM_USED, stack.item());
    world.game_event(
        &vanilla_game_events::BLOCK_CHANGE,
        pos,
        &GameEventContext::new(Some(player), Some(state)),
    );
    let has_infinite_materials = player.has_infinite_materials();
    inv.with_item(|item| item.consume_one(has_infinite_materials));

    InteractionResult::Success
}

/// Attempts to open the sign editor for a player.
///
/// Checks all conditions required by vanilla:
/// 1. Block entity exists and is a sign
/// 2. Sign is not waxed
/// 3. No other player is currently editing
/// 4. Player has build permission (`may_build`)
/// 5. Facing side contains only editable text
///
/// Returns `Success` if the editor was opened, `Pass` otherwise.
fn try_open_sign_editor(
    state: BlockStateId,
    world: &Arc<World>,
    pos: BlockPos,
    player: &Player,
) -> InteractionResult {
    // Get the block entity
    let Some(block_entity) = world.get_block_entity(pos) else {
        return InteractionResult::Pass;
    };

    let Some(sign) = block_entity.downcast_ref::<SignBlockEntity>() else {
        return InteractionResult::Pass;
    };

    if sign.is_waxed() {
        world.play_sound(
            sign.sign_interaction_failed_sound_event(),
            SoundSource::Blocks,
            pos,
            1.0,
            1.0,
            None,
        );
        return InteractionResult::Success; // Vanilla returns SUCCESS even when waxed
    }

    if sign.is_other_player_editing(player.gameprofile.id()) {
        return InteractionResult::Pass;
    }

    if !player.abilities.lock().may_build {
        return InteractionResult::Pass;
    }

    // Determine which side the player is facing
    let slot = facing_text_slot(state, pos, player);
    if !sign.get_text(slot).has_editable_text() {
        return InteractionResult::Pass;
    }

    open_text_edit(sign, player, pos, slot);
    InteractionResult::Success
}

/// Opens the sign editor for `player`, taking the edit lock.
fn open_text_edit(sign: &SignBlockEntity, player: &Player, pos: BlockPos, slot: SignTextSlot) {
    sign.set_player_who_may_edit(Some(player.gameprofile.id()));
    player.open_sign_editor(pos, slot);
}

/// Opens the front text editor for the player who just placed the sign.
fn open_sign_editor_on_place(world: &Arc<World>, pos: BlockPos, player: &Player) {
    let Some(block_entity) = world.get_block_entity(pos) else {
        return;
    };
    let Some(sign) = block_entity.downcast_ref::<SignBlockEntity>() else {
        return;
    };
    if sign.is_waxed() || !sign.get_text(SignTextSlot::Front).has_editable_text() {
        return;
    }

    open_text_edit(sign, player, pos, SignTextSlot::Front);
}

/// Behavior for standing sign blocks (placed on ground).
#[block_behavior]
pub struct StandingSignBlock {
    block: BlockRef,
}

const ATTACHED: &BoolProperty = &BlockStateProperties::ATTACHED;
const HORIZONTAL_FACING: &EnumProperty<Direction> = &BlockStateProperties::HORIZONTAL_FACING;
const ROTATION_16: &IntProperty = &BlockStateProperties::ROTATION_16;

impl StandingSignBlock {
    /// Creates a new standing sign block behavior.
    #[must_use]
    pub const fn new(block: BlockRef) -> Self {
        Self { block }
    }
}

impl BlockBehavior for StandingSignBlock {
    fn is_possible_to_respawn_in_this(&self, _state: BlockStateId) -> bool {
        true
    }

    fn update_shape(
        &self,
        state: BlockStateId,
        world: &dyn ScheduledTickAccess,
        pos: BlockPos,
        direction: Direction,
        _neighbor_pos: BlockPos,
        _neighbor_state: BlockStateId,
    ) -> BlockStateId {
        // Standing signs break when the block below is removed
        if direction == Direction::Down && !can_support_standing_sign(world, pos) {
            return REGISTRY.blocks.get_default_state_id(&vanilla_blocks::AIR);
        }
        schedule_water_tick_if_waterlogged(state, world, pos);
        state
    }

    fn get_state_for_placement(&self, context: &BlockPlaceContext<'_>) -> Option<BlockStateId> {
        // Check if we can place on the block below
        if !can_support_standing_sign(context.world, context.place_pos()) {
            return None;
        }

        // Calculate rotation from player's yaw
        // Vanilla: RotationSegment.convertToSegment(context.getRotation() + 180.0F)
        let rotation = convert_to_rotation_segment(context.rotation() + DEGREE_180);

        Some(self.block.default_state().set_value(ROTATION_16, rotation))
    }

    fn new_block_entity(
        &self,
        level: Weak<World>,
        pos: BlockPos,
        state: BlockStateId,
    ) -> BlockEntityCreation {
        BlockEntityCreation::Created(Arc::new(SignBlockEntity::new(level, pos, state)))
    }

    fn get_block_entity_ticker(
        &self,
        _world: &Arc<World>,
        _state: BlockStateId,
        block_entity_type: BlockEntityTypeRef,
    ) -> Option<BlockEntityTicker> {
        BlockEntityTicker::for_matching_entity_tick(
            block_entity_type,
            &vanilla_block_entity_types::SIGN,
        )
    }

    fn use_item_on(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hand: InteractionHand,
        _hit_result: &BlockHitResult,
        inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_apply_sign_item(state, world, pos, player, inv)
    }

    fn use_without_item(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hit_result: &BlockHitResult,
        _inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_open_sign_editor(state, world, pos, player)
    }

    fn set_placed_by(
        &self,
        _state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        source: &PlacementSource<'_>,
    ) {
        if let Some(player) = source.player() {
            open_sign_editor_on_place(world, pos, player);
        }
    }
}

/// Behavior for wall sign blocks (attached to walls).
#[block_behavior]
pub struct WallSignBlock {
    block: BlockRef,
}

impl WallSignBlock {
    /// Creates a new wall sign block behavior.
    #[must_use]
    pub const fn new(block: BlockRef) -> Self {
        Self { block }
    }
}

impl BlockBehavior for WallSignBlock {
    fn is_possible_to_respawn_in_this(&self, _state: BlockStateId) -> bool {
        true
    }

    fn update_shape(
        &self,
        state: BlockStateId,
        world: &dyn ScheduledTickAccess,
        pos: BlockPos,
        direction: Direction,
        _neighbor_pos: BlockPos,
        _neighbor_state: BlockStateId,
    ) -> BlockStateId {
        // Wall signs break when the block they're attached to is removed
        // The sign is attached to the block opposite of its facing direction
        if let Some(facing) = state.try_get_value(HORIZONTAL_FACING)
            && direction.opposite() == facing
            && !can_wall_sign_survive(world, pos, facing)
        {
            return REGISTRY.blocks.get_default_state_id(&vanilla_blocks::AIR);
        }
        schedule_water_tick_if_waterlogged(state, world, pos);
        state
    }

    fn get_state_for_placement(&self, context: &BlockPlaceContext<'_>) -> Option<BlockStateId> {
        // Try each horizontal direction based on player's look direction
        let directions = get_nearest_looking_directions(context.rotation(), context.clicked_face());

        for direction in directions {
            // The sign faces the opposite direction of where it's attached
            let facing = direction.opposite();

            // Check if sign can survive with this facing
            if can_wall_sign_survive(context.world, context.place_pos(), facing) {
                return Some(
                    self.block
                        .default_state()
                        .set_value(HORIZONTAL_FACING, facing),
                );
            }
        }

        // No valid placement found
        None
    }

    fn new_block_entity(
        &self,
        level: Weak<World>,
        pos: BlockPos,
        state: BlockStateId,
    ) -> BlockEntityCreation {
        BlockEntityCreation::Created(Arc::new(SignBlockEntity::new(level, pos, state)))
    }

    fn get_block_entity_ticker(
        &self,
        _world: &Arc<World>,
        _state: BlockStateId,
        block_entity_type: BlockEntityTypeRef,
    ) -> Option<BlockEntityTicker> {
        BlockEntityTicker::for_matching_entity_tick(
            block_entity_type,
            &vanilla_block_entity_types::SIGN,
        )
    }

    fn use_item_on(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hand: InteractionHand,
        _hit_result: &BlockHitResult,
        inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_apply_sign_item(state, world, pos, player, inv)
    }

    fn use_without_item(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hit_result: &BlockHitResult,
        _inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_open_sign_editor(state, world, pos, player)
    }

    fn set_placed_by(
        &self,
        _state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        source: &PlacementSource<'_>,
    ) {
        if let Some(player) = source.player() {
            open_sign_editor_on_place(world, pos, player);
        }
    }
}

/// Behavior for ceiling hanging sign blocks.
#[block_behavior]
pub struct CeilingHangingSignBlock {
    block: BlockRef,
}

impl CeilingHangingSignBlock {
    /// Creates a new ceiling hanging sign block behavior.
    #[must_use]
    pub const fn new(block: BlockRef) -> Self {
        Self { block }
    }
}

impl BlockBehavior for CeilingHangingSignBlock {
    fn is_possible_to_respawn_in_this(&self, _state: BlockStateId) -> bool {
        true
    }

    fn update_shape(
        &self,
        state: BlockStateId,
        world: &dyn ScheduledTickAccess,
        pos: BlockPos,
        direction: Direction,
        _neighbor_pos: BlockPos,
        _neighbor_state: BlockStateId,
    ) -> BlockStateId {
        // Ceiling hanging signs break when the block above is removed
        if direction == Direction::Up && !can_ceiling_hanging_sign_survive(world, pos) {
            return REGISTRY.blocks.get_default_state_id(&vanilla_blocks::AIR);
        }
        schedule_water_tick_if_waterlogged(state, world, pos);
        state
    }

    fn get_state_for_placement(&self, context: &BlockPlaceContext<'_>) -> Option<BlockStateId> {
        // Check if we can hang from the block above
        if !can_ceiling_hanging_sign_survive(context.world, context.place_pos()) {
            return None;
        }

        let above_pos = BlockPos::new(
            context.place_pos().x(),
            context.place_pos().y() + 1,
            context.place_pos().z(),
        );
        let above_state = context.world.get_block_state(above_pos);

        // Determine if we should attach to the middle or not based on block above
        let direction = Direction::from_yaw(context.rotation());
        let is_above_full = context.world.is_face_sturdy_for(
            above_state,
            above_pos,
            Direction::Down,
            SupportType::Full,
        );

        // Check if block above is also a hanging sign
        let above_block = REGISTRY.blocks.by_state_id(above_state);
        let is_below_hanging_sign =
            above_block.is_some_and(|b| b.key.path.contains("hanging_sign"));

        // Determine if attached to middle based on vanilla logic
        let attached_to_middle = if is_below_hanging_sign {
            // When below another hanging sign, check if we can chain
            if let Some(above_facing) = above_state.try_get_value(HORIZONTAL_FACING) {
                // Wall hanging sign above - check axis alignment
                above_facing.axis() != direction.axis()
            } else if let Some(above_rotation) = above_state.try_get_value(ROTATION_16) {
                // Ceiling hanging sign above - check if we can align
                let above_direction = rotation_to_direction(above_rotation);
                above_direction.is_none_or(|d| d.axis() != direction.axis())
            } else {
                !is_above_full
            }
        } else {
            !is_above_full
        };

        // Calculate rotation
        let rotation = if attached_to_middle {
            // Attached to middle - use player rotation
            convert_to_rotation_segment(context.rotation() + DEGREE_180)
        } else {
            // Attached to chains - align with direction
            convert_to_rotation_segment(direction.opposite().to_yaw())
        };

        Some(
            self.block
                .default_state()
                .set_value(ROTATION_16, rotation)
                .set_value(ATTACHED, attached_to_middle),
        )
    }

    fn new_block_entity(
        &self,
        level: Weak<World>,
        pos: BlockPos,
        state: BlockStateId,
    ) -> BlockEntityCreation {
        BlockEntityCreation::Created(Arc::new(SignBlockEntity::new_hanging(level, pos, state)))
    }

    fn get_block_entity_ticker(
        &self,
        _world: &Arc<World>,
        _state: BlockStateId,
        block_entity_type: BlockEntityTypeRef,
    ) -> Option<BlockEntityTicker> {
        BlockEntityTicker::for_matching_entity_tick(
            block_entity_type,
            &vanilla_block_entity_types::HANGING_SIGN,
        )
    }

    fn use_item_on(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hand: InteractionHand,
        _hit_result: &BlockHitResult,
        inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_apply_sign_item(state, world, pos, player, inv)
    }

    fn use_without_item(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hit_result: &BlockHitResult,
        _inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_open_sign_editor(state, world, pos, player)
    }

    fn set_placed_by(
        &self,
        _state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        source: &PlacementSource<'_>,
    ) {
        if let Some(player) = source.player() {
            open_sign_editor_on_place(world, pos, player);
        }
    }
}

/// Converts a rotation segment (0-15) to a cardinal direction, if applicable.
const fn rotation_to_direction(rotation: u8) -> Option<Direction> {
    match rotation {
        0 => Some(Direction::South),
        4 => Some(Direction::West),
        8 => Some(Direction::North),
        12 => Some(Direction::East),
        _ => None,
    }
}

/// Behavior for wall hanging sign blocks.
#[block_behavior]
pub struct WallHangingSignBlock {
    block: BlockRef,
}

impl WallHangingSignBlock {
    /// Creates a new wall hanging sign block behavior.
    #[must_use]
    pub const fn new(block: BlockRef) -> Self {
        Self { block }
    }
}

impl BlockBehavior for WallHangingSignBlock {
    fn is_possible_to_respawn_in_this(&self, _state: BlockStateId) -> bool {
        true
    }

    fn update_shape(
        &self,
        state: BlockStateId,
        world: &dyn ScheduledTickAccess,
        pos: BlockPos,
        direction: Direction,
        _neighbor_pos: BlockPos,
        _neighbor_state: BlockStateId,
    ) -> BlockStateId {
        // Wall hanging signs break when blocks on the perpendicular axis are removed
        // and they can no longer survive
        if let Some(facing) = state.try_get_value(HORIZONTAL_FACING) {
            // Check if the change is on the perpendicular axis (clockwise/counterclockwise)
            if direction.axis() == facing.rotate_y_clockwise().axis()
                && !can_wall_hanging_sign_survive(world, pos, facing)
            {
                return REGISTRY.blocks.get_default_state_id(&vanilla_blocks::AIR);
            }
        }
        schedule_water_tick_if_waterlogged(state, world, pos);
        state
    }

    fn get_state_for_placement(&self, context: &BlockPlaceContext<'_>) -> Option<BlockStateId> {
        // Try each horizontal direction based on player's look direction
        let directions = get_nearest_looking_directions(context.rotation(), context.clicked_face());

        for direction in directions {
            // Wall hanging signs face perpendicular to the wall they're attached to
            // Skip if the clicked face is on the same axis
            if direction.axis() == context.clicked_face().axis() {
                continue;
            }

            let facing = direction.opposite();

            // Check if sign can survive with this facing
            if can_wall_hanging_sign_survive(context.world, context.place_pos(), facing) {
                return Some(
                    self.block
                        .default_state()
                        .set_value(HORIZONTAL_FACING, facing),
                );
            }
        }

        // No valid placement found
        None
    }

    fn new_block_entity(
        &self,
        level: Weak<World>,
        pos: BlockPos,
        state: BlockStateId,
    ) -> BlockEntityCreation {
        BlockEntityCreation::Created(Arc::new(SignBlockEntity::new_hanging(level, pos, state)))
    }

    fn get_block_entity_ticker(
        &self,
        _world: &Arc<World>,
        _state: BlockStateId,
        block_entity_type: BlockEntityTypeRef,
    ) -> Option<BlockEntityTicker> {
        BlockEntityTicker::for_matching_entity_tick(
            block_entity_type,
            &vanilla_block_entity_types::HANGING_SIGN,
        )
    }

    fn use_item_on(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hand: InteractionHand,
        _hit_result: &BlockHitResult,
        inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_apply_sign_item(state, world, pos, player, inv)
    }

    fn use_without_item(
        &self,
        state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        player: &Player,
        _hit_result: &BlockHitResult,
        _inv: &mut InventoryAccess,
    ) -> InteractionResult {
        try_open_sign_editor(state, world, pos, player)
    }

    fn set_placed_by(
        &self,
        _state: BlockStateId,
        world: &Arc<World>,
        pos: BlockPos,
        source: &PlacementSource<'_>,
    ) {
        if let Some(player) = source.player() {
            open_sign_editor_on_place(world, pos, player);
        }
    }
}

#[cfg(test)]
mod tests {
    use steel_registry::data_components::vanilla_components::DYE;
    use steel_registry::item_stack::ItemStack;
    use steel_registry::{DyeColor, init_vanilla_registry, vanilla_items};
    use steel_utils::ChunkPos;
    use steel_utils::types::UpdateFlags;
    use text_components::TextComponent;

    use super::*;
    use crate::behavior::init_behaviors;
    use crate::block_entity::entities::SignText;
    use crate::test_support::{
        TestLevel, TestPlayerBuilder, fresh_test_world, insert_ready_full_chunk,
    };

    const WATERLOGGED: &BoolProperty = &BlockStateProperties::WATERLOGGED;

    #[test]
    fn standing_sign_only_schedules_water_when_support_survives() {
        init_vanilla_registry();
        let pos = BlockPos::new(0, 64, 0);
        let sign = StandingSignBlock::new(&vanilla_blocks::OAK_SIGN);
        let state = vanilla_blocks::OAK_SIGN
            .default_state()
            .set_value(WATERLOGGED, true);
        let supported =
            TestLevel::default().with_block(pos.below(), vanilla_blocks::STONE.default_state());

        assert_eq!(
            sign.update_shape(
                state,
                &supported,
                pos,
                Direction::North,
                pos.north(),
                vanilla_blocks::AIR.default_state(),
            ),
            state
        );
        assert!(supported.scheduled_water_tick());

        let unsupported = TestLevel::default();
        assert!(
            sign.update_shape(
                state,
                &unsupported,
                pos,
                Direction::Down,
                pos.below(),
                vanilla_blocks::AIR.default_state(),
            )
            .is_air()
        );
        assert!(!unsupported.scheduled_water_tick());
    }

    #[test]
    fn sign_variants_select_their_matching_vanilla_tickers() {
        init_vanilla_registry();
        let world_fixture = fresh_test_world("sign_ticker_selection");
        let world = &world_fixture.world;

        let standing = StandingSignBlock::new(&vanilla_blocks::OAK_SIGN);
        assert!(
            standing
                .get_block_entity_ticker(
                    world,
                    vanilla_blocks::OAK_SIGN.default_state(),
                    &vanilla_block_entity_types::SIGN,
                )
                .is_some()
        );

        let wall = WallSignBlock::new(&vanilla_blocks::OAK_WALL_SIGN);
        assert!(
            wall.get_block_entity_ticker(
                world,
                vanilla_blocks::OAK_WALL_SIGN.default_state(),
                &vanilla_block_entity_types::SIGN,
            )
            .is_some()
        );

        let ceiling_hanging = CeilingHangingSignBlock::new(&vanilla_blocks::OAK_HANGING_SIGN);
        assert!(
            ceiling_hanging
                .get_block_entity_ticker(
                    world,
                    vanilla_blocks::OAK_HANGING_SIGN.default_state(),
                    &vanilla_block_entity_types::HANGING_SIGN,
                )
                .is_some()
        );

        let wall_hanging = WallHangingSignBlock::new(&vanilla_blocks::OAK_WALL_HANGING_SIGN);
        assert!(
            wall_hanging
                .get_block_entity_ticker(
                    world,
                    vanilla_blocks::OAK_WALL_HANGING_SIGN.default_state(),
                    &vanilla_block_entity_types::HANGING_SIGN,
                )
                .is_some()
        );
        assert!(
            wall_hanging
                .get_block_entity_ticker(
                    world,
                    vanilla_blocks::OAK_WALL_HANGING_SIGN.default_state(),
                    &vanilla_block_entity_types::SIGN,
                )
                .is_none()
        );
    }

    #[test]
    fn try_open_sign_editor_checks_waxed_and_may_build() {
        init_vanilla_registry();
        let world_fixture = fresh_test_world("sign_editor_checks");
        let world = &world_fixture.world;
        let pos = BlockPos::new(0, 64, 0);
        insert_ready_full_chunk(world, ChunkPos::new(0, 0));
        let state = vanilla_blocks::OAK_SIGN.default_state();
        assert!(world.set_block(pos, state, UpdateFlags::UPDATE_ALL));

        let sign = Arc::new(SignBlockEntity::new(Arc::downgrade(world), pos, state));
        let block_entity: Arc<dyn BlockEntity> = Arc::<SignBlockEntity>::clone(&sign);
        assert!(world.set_block_entity(block_entity));

        let player = TestPlayerBuilder::new(Arc::clone(world), "Editor", 1).build();

        sign.wax();
        assert_eq!(
            try_open_sign_editor(state, world, pos, &player),
            InteractionResult::Success
        );

        let unwaxed = Arc::new(SignBlockEntity::new(Arc::downgrade(world), pos, state));
        assert!(world.set_block_entity(unwaxed));
        player.abilities.lock().may_build = false;
        assert_eq!(
            try_open_sign_editor(state, world, pos, &player),
            InteractionResult::Pass
        );
    }

    #[test]
    fn try_apply_sign_item_dyes_sign_text() {
        init_vanilla_registry();
        init_behaviors();
        let world_fixture = fresh_test_world("sign_dye_application");
        let world = &world_fixture.world;
        let pos = BlockPos::new(0, 64, 0);
        insert_ready_full_chunk(world, ChunkPos::new(0, 0));
        let state = vanilla_blocks::OAK_SIGN.default_state();
        assert!(world.set_block(pos, state, UpdateFlags::UPDATE_ALL));

        let sign = Arc::new(SignBlockEntity::new(Arc::downgrade(world), pos, state));
        let mut text = SignText::new();
        text.set_message(0, TextComponent::plain("Steel"));
        sign.set_text(text, SignTextSlot::Front);
        let block_entity: Arc<dyn BlockEntity> = Arc::<SignBlockEntity>::clone(&sign);
        assert!(world.set_block_entity(block_entity));

        let player = TestPlayerBuilder::new(Arc::clone(world), "Painter", 2).build();
        let mut dye_stack = ItemStack::new(&vanilla_items::RED_DYE);
        dye_stack.set(DYE, DyeColor::Red);
        player
            .inventory
            .lock()
            .set_item_in_hand(InteractionHand::MainHand, dye_stack.clone());

        let mut inv =
            InventoryAccess::new(Arc::clone(&player.inventory), InteractionHand::MainHand);
        assert_eq!(
            try_apply_sign_item(state, world, pos, &player, &mut inv),
            InteractionResult::Success
        );
        assert_eq!(sign.get_text(SignTextSlot::Front).color, DyeColor::Red);
        assert_eq!(
            player
                .inventory
                .lock()
                .get_item_in_hand(InteractionHand::MainHand)
                .count(),
            0
        );

        player
            .inventory
            .lock()
            .set_item_in_hand(InteractionHand::MainHand, dye_stack);
        let mut inv =
            InventoryAccess::new(Arc::clone(&player.inventory), InteractionHand::MainHand);
        assert_eq!(
            try_apply_sign_item(state, world, pos, &player, &mut inv),
            InteractionResult::TryEmptyHandInteraction
        );
    }
}