path: root/src/Blocks/BlockButton.h

#pragma once

#include "BlockHandler.h"
#include "BlockSlab.h"
#include "BlockStairs.h"
#include "../BlockInfo.h"
#include "../Chunk.h"
#include "Defines.h"
#include "Entities/Player.h"
#include "Mixins.h"
#include "ChunkInterface.h"
#include "World.h"




class cBlockButtonHandler final
	: public cClearMetaOnDrop<cMetaRotator<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>>
{
	using Super = cClearMetaOnDrop<cMetaRotator<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>>;

  public:
	using Super::Super;

	/** Extracts the ON bit from metadata and returns if true if it is set */
	static bool IsButtonOn(NIBBLETYPE a_Meta) { return (a_Meta & 0x08) == 0x08; }

	/** Event handler for an arrow striking a block.
	Performs appropriate handling if the arrow intersected a wooden button. */
	static void OnArrowHit(cWorld & a_World, const Vector3i a_Position, const eBlockFace a_HitFace)
	{
		BLOCKTYPE Type;
		NIBBLETYPE Meta;
		const auto Pos = AddFaceDirection(a_Position, a_HitFace);

		if (!a_World.GetBlockTypeMeta(Pos, Type, Meta) || IsButtonOn(Meta) ||
			!IsButtonPressedByArrow(a_World, Pos, Type, Meta))
		{
			// Bail if we're not specifically a wooden button, or it's already on
			// or if the arrow didn't intersect. It is very important that nothing is
			// done if the button is depressed, since the release task will already be queued
			return;
		}

		a_World.SetBlockMeta(Pos, Meta | 0x08);
		a_World.WakeUpSimulators(Pos);

		// sound name is ok to be wood, because only wood gets triggered by arrow
		a_World.GetBroadcastManager().BroadcastSoundEffect("block.wood_button.click_on", Pos, 0.5f, 0.6f);

		// Queue a button reset
		QueueButtonRelease(a_World, Pos, Type);
	}

  private:
	virtual bool OnUse(
		cChunkInterface & a_ChunkInterface,
		cWorldInterface & a_WorldInterface,
		cPlayer & a_Player,
		const Vector3i a_BlockPos,
		eBlockFace a_BlockFace,
		const Vector3i a_CursorPos
	) const override
	{
		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockPos);

		// If button is already on, do nothing:
		if (IsButtonOn(Meta))
		{
			return false;
		}

		// Set the ON bit to on
		Meta |= 0x08;

		const auto SoundToPlay =
			(m_BlockType == E_BLOCK_STONE_BUTTON) ? "block.stone_button.click_on" : "block.wood_button.click_on";

		a_ChunkInterface.SetBlockMeta(a_BlockPos, Meta);
		a_WorldInterface.WakeUpSimulators(a_BlockPos);
		a_WorldInterface.GetBroadcastManager()
			.BroadcastSoundEffect(SoundToPlay, a_BlockPos, 0.5f, 0.6f, a_Player.GetClientHandle());

		// Queue a button reset (unpress)
		QueueButtonRelease(*a_Player.GetWorld(), a_BlockPos, m_BlockType);

		return true;
	}





	virtual bool IsUseable(void) const override { return true; }





	/** Converts the block meta of this button into a block face of the neighbor to which the button is attached. */
	inline static eBlockFace BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
	{
		switch (a_Meta & 0x7)
		{
			case 0x0: return BLOCK_FACE_YM;
			case 0x1: return BLOCK_FACE_XP;
			case 0x2: return BLOCK_FACE_XM;
			case 0x3: return BLOCK_FACE_ZP;
			case 0x4: return BLOCK_FACE_ZM;
			case 0x5: return BLOCK_FACE_YP;
			default:
			{
				ASSERT(!"Unhandled block meta!");
				return BLOCK_FACE_NONE;
			}
		}
	}





	virtual bool CanBeAt(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_Meta) const override
	{
		auto SupportRelPos = AddFaceDirection(a_Position, BlockMetaDataToBlockFace(a_Meta), true);
		if (!cChunkDef::IsValidHeight(SupportRelPos))
		{
			return false;
		}
		BLOCKTYPE SupportBlockType;
		NIBBLETYPE SupportBlockMeta;
		a_Chunk.UnboundedRelGetBlock(SupportRelPos, SupportBlockType, SupportBlockMeta);
		eBlockFace Face = BlockMetaDataToBlockFace(a_Meta);

		// upside down slabs
		if (cBlockSlabHandler::IsAnySlabType(SupportBlockType))
		{
			return (Face == BLOCK_FACE_YP) && (SupportBlockMeta & E_META_WOODEN_SLAB_UPSIDE_DOWN);
		}

		// stairs (top and sides)
		if (cBlockStairsHandler::IsAnyStairType(SupportBlockType))
		{
			switch (Face)
			{
				case eBlockFace::BLOCK_FACE_YP: return (SupportBlockMeta & E_BLOCK_STAIRS_UPSIDE_DOWN);
				case eBlockFace::BLOCK_FACE_XP: return ((SupportBlockMeta & 0b11) == E_BLOCK_STAIRS_XP);
				case eBlockFace::BLOCK_FACE_XM: return ((SupportBlockMeta & 0b11) == E_BLOCK_STAIRS_XM);
				case eBlockFace::BLOCK_FACE_ZP: return ((SupportBlockMeta & 0b11) == E_BLOCK_STAIRS_ZP);
				case eBlockFace::BLOCK_FACE_ZM: return ((SupportBlockMeta & 0b11) == E_BLOCK_STAIRS_ZM);
				default:
				{
					return false;
				}
			}
		}

		return cBlockInfo::FullyOccupiesVoxel(SupportBlockType);
	}





	virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override
	{
		UNUSED(a_Meta);
		return 0;
	}

	/** Schedules a recurring event at appropriate intervals to release a button at a given position.
	The given block type is checked when the task is executed to ensure the position still contains a button. */
	static void QueueButtonRelease(cWorld & a_ButtonWorld, const Vector3i a_Position, const BLOCKTYPE a_BlockType)
	{
		const auto TickDelay = (a_BlockType == E_BLOCK_STONE_BUTTON) ? 20_tick : 30_tick;
		a_ButtonWorld.ScheduleTask(
			TickDelay,
			[a_Position, a_BlockType](cWorld & a_World)
			{
				BLOCKTYPE Type;
				NIBBLETYPE Meta;

				if (!a_World.GetBlockTypeMeta(a_Position, Type, Meta) || (Type != a_BlockType) || !IsButtonOn(Meta))
				{
					// Total failure or block changed, bail
					return;
				}

				if (IsButtonPressedByArrow(a_World, a_Position, Type, Meta))
				{
					// Try again in a little while
					QueueButtonRelease(a_World, a_Position, a_BlockType);
					return;
				}

				// Block hasn't change in the meantime; release it
				const auto SoundToPlayOnRelease =
					(Type == E_BLOCK_STONE_BUTTON) ? "block.stone_button.click_off" : "block.wood_button.click_off";

				a_World.SetBlockMeta(a_Position, Meta & 0x07);
				a_World.WakeUpSimulators(a_Position);
				a_World.BroadcastSoundEffect(SoundToPlayOnRelease, a_Position, 0.5f, 0.5f);
			}
		);
	}

	/** Returns true if an arrow was found in the wooden button */
	static bool IsButtonPressedByArrow(
		cWorld & a_World,
		const Vector3i a_ButtonPosition,
		const BLOCKTYPE a_BlockType,
		const NIBBLETYPE a_Meta
	)
	{
		if (a_BlockType != E_BLOCK_WOODEN_BUTTON)
		{
			return false;
		}

		const auto FaceOffset = GetButtonOffsetOnBlock(a_Meta);
		const bool FoundArrow = !a_World.ForEachEntityInBox(
			cBoundingBox(FaceOffset + a_ButtonPosition, 0.2, 0.2),
			[](cEntity & a_Entity) { return a_Entity.IsArrow(); }
		);

		return FoundArrow;
	}

	/** Returns an offset to the integer world coordinates of a button.
	Applying this offset yields the centre of the button's bounding box,
	in terms of the position within the block the button with given meta occupies.

	TODO: this is only approximate, return the exact bbox instead. */
	static Vector3d GetButtonOffsetOnBlock(NIBBLETYPE a_Meta)
	{
		switch (BlockMetaDataToBlockFace(a_Meta))
		{
			case BLOCK_FACE_YM: return {0.5, 1, 0.5};
			case BLOCK_FACE_XP: return {0, 0.5, 0.5};
			case BLOCK_FACE_XM: return {1, 0.5, 0.5};
			case BLOCK_FACE_ZP: return {0.5, 0.5, 0};
			case BLOCK_FACE_ZM: return {0.5, 0.5, 1};
			case BLOCK_FACE_YP: return {0.5, 0, 0.5};
			case BLOCK_FACE_NONE:
			{
				break;
			}
		}
		UNREACHABLE("Unhandled block face!");
	}
};