Block.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
#include "mc/world/level/block/BlockType.h"
 
// auto generated inclusion list
#include "mc/deps/core/utility/optional_ref.h"
#include "mc/deps/nbt/CompoundTag.h"
#include "mc/platform/brstd/function_ref.h"
#include "mc/world/level/ShapeType.h"
#include "mc/world/level/block/BlockType.h"
#include "mc/world/level/block/CachedComponentData.h"
#include "mc/world/level/block/components/BlockComponentDirectData.h"
#include "mc/world/level/block/components/BlockComponentStorage.h"
 
// auto generated forward declare list
// clang-format off
class AABB;
class Actor;
class BaseGameVersion;
class BlockPos;
class BlockSource;
class BlockState;
class BlockType;
class GetCollisionShapeInterface;
class HashedString;
class HitResult;
class IClientBlockData;
class IConstBlockSource;
class IRandom;
class ItemActor;
class ItemInstance;
class ItemStackBase;
class NeighborBlockDirections;
class Player;
class Random;
class Vec3;
struct BlockAnimateTickData;
struct ResourceDropsContext;
namespace VoxelShapes { class VoxelShape; }
// clang-format on
 
class Block {
public:
    using BlockStateValueType = std::variant<int, float, bool, std::string>;
    using BlockStatesType     = std::vector<std::pair<std::string, BlockStateValueType>>;
 
    LLNDAPI static optional_ref<Block const> tryGetFromRegistry(uint runtimeID);
    LLNDAPI static optional_ref<Block const> tryGetFromRegistry(uint legacyBlockID, ushort legacyData);
    LLNDAPI static optional_ref<Block const> tryGetFromRegistry(HashedString const& name);
    LLNDAPI static optional_ref<Block const> tryGetFromRegistry(HashedString const& name, ushort legacyData);
    LLNDAPI static optional_ref<Block const>
    tryGetFromRegistry(HashedString const& name, BlockStatesType const& states);
    LLNDAPI static optional_ref<Block const> tryGetFromRegistry(CompoundTag const& nbt);
 
    LLNDAPI bool isAir() const;
 
    [[nodiscard]] BlockType const& getBlockType() const { return *mBlockType; }
 
    [[nodiscard]] std::string const& getTypeName() const { return getBlockType().getTypeName(); }
 
    [[nodiscard]] unsigned short getBlockItemId() const { return getBlockType().mID->mValue; }
 
    [[nodiscard]] ushort getData() const { return mData; }
 
    template <typename T>
    std::optional<T> getState(uint64 id) const {
        return mBlockType->getState<T>(id, mData);
    }
 
    template <typename T>
    std::optional<T> getState(BlockState const& state) const {
        return mBlockType->getState<T>(state, mData);
    }
 
    template <typename T>
    optional_ref<Block const> setState(uint64 id, T value) const {
        return mBlockType->trySetState(id, value, mData);
    }
 
    template <typename T>
    optional_ref<Block const> setState(BlockState const& state, T value) const {
        return mBlockType->trySetState(state, value, mData);
    }
 
    bool operator==(Block const& other) const { return mSerializationIdHash == other.mSerializationIdHash; }
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 80, ::BlockComponentStorage>              mComponents;
    ::ll::TypedStorage<8, 8, ::gsl::not_null<::BlockType*>>         mBlockType;
    ::ll::TypedStorage<4, 8, ::CachedComponentData>                 mCachedComponentData;
    ::ll::TypedStorage<8, 96, ::BlockComponentDirectData>           mDirectData;
    ::ll::TypedStorage<8, 24, ::std::vector<::HashedString>>        mTags;
    ::ll::TypedStorage<8, 24, ::CompoundTag>                        mSerializationId;
    ::ll::TypedStorage<8, 8, uint64>                                mSerializationIdHash;
    ::ll::TypedStorage<4, 4, uint>                                  mSerializationIdHashForNetwork;
    ::ll::TypedStorage<4, 4, uint>                                  mNetworkId;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::IClientBlockData>> mClientData;
    ::ll::TypedStorage<2, 2, ushort const>                          mData;
    ::ll::TypedStorage<1, 1, bool>                                  mHasRuntimeId;
    // NOLINTEND
 
public:
    // prevent constructor by default
    Block();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~Block() = default;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI Block(ushort data, ::gsl::not_null<::BlockType*> oldBlock);
 
    MCAPI Block(ushort data, ::gsl::not_null<::BlockType*> oldBlock, ::CompoundTag serId, uint const& runId);
 
#ifdef LL_PLAT_C
    MCAPI void _playAmbientSounds(::BlockAnimateTickData const& tickData) const;
#endif
 
    MCAPI void _removeFromTickingQueues(::BlockSource& region, ::BlockPos const& pos) const;
 
    MCAPI ::ItemInstance asItemInstance(::BlockSource& region, ::BlockPos const& position, bool withData) const;
 
    MCAPI bool breaksFallingBlocks(::BaseGameVersion version) const;
 
    MCAPI ::std::string buildDescriptionName() const;
 
    MCAPI void buildSerializationId(uint latestUpdaterVersion);
 
    MCAPI bool canConnect(::Block const& connectionBlock, uchar toOther) const;
 
    MCAPI bool canFillAtPos(::BlockSource& region, ::BlockPos const& pos) const;
 
    MCAPI bool canSurvive(::BlockSource& region, ::BlockPos const& pos) const;
 
    MCAPI ::HitResult clip(
        ::BlockSource const&                               region,
        ::BlockPos const&                                  pos,
        ::Vec3 const&                                      A,
        ::Vec3 const&                                      B,
        ::ShapeType                                        shapeType,
        ::optional_ref<::GetCollisionShapeInterface const> entity
    ) const;
 
    MCAPI uint computeRawSerializationIdHashForNetwork() const;
 
    MCAPI ::Block const& connectionUpdate(
        ::BlockSource&            region,
        ::BlockPos const&         pos,
        ::NeighborBlockDirections neighborBlockDirections
    ) const;
 
    MCAPI ::Block const& copyState(::Block const& fromBlock, ::BlockState const& state) const;
 
    MCAPI ::Block const& copyStates(::Block const& fromBlock) const;
 
    MCAPI void executeItemEvent(
        ::ItemStackBase&     item,
        ::std::string const& eventName,
        ::BlockSource&       region,
        ::BlockPos const&    pos,
        ::Actor*             actor
    ) const;
 
#ifdef LL_PLAT_C
    MCAPI void forEachState(::brstd::function_ref<bool(::BlockState const&, int)> callback) const;
#endif
 
    MCAPI bool getCollisionShape(
        ::AABB&                                            outAABB,
        ::IConstBlockSource const&                         region,
        ::BlockPos const&                                  pos,
        ::optional_ref<::GetCollisionShapeInterface const> entity
    ) const;
 
#ifdef LL_PLAT_C
    MCAPI ::BlockType::HorizontalDirectionBits
    getConnectedDirections(::BlockPos const& pos, ::BlockSource& region) const;
 
    MCAPI ::std::string getCraftingLabelText() const;
#endif
 
    MCAPI ::std::string getDescriptionId() const;
 
#ifdef LL_PLAT_C
    MCAPI ::VoxelShapes::VoxelShape const* getOcclusionFaceShape(uchar face) const;
 
    MCAPI ::AABB const& getOutline(::IConstBlockSource const& region, ::BlockPos const& pos, ::AABB& bufferValue) const;
#endif
 
#ifdef LL_PLAT_S
    MCAPI ::Vec3 getRandomOffset(::BlockPos const& pos) const;
#endif
 
#ifdef LL_PLAT_C
    MCAPI bool getSecondPart(::BlockSource const& region, ::BlockPos const& pos, ::BlockPos& out) const;
#endif
 
    MCAPI ::Block const& getStateFromLegacyData(ushort data) const;
 
    MCAPI bool hasState(::HashedString const& name) const;
 
    MCAPI bool hasState(::BlockState const& stateType) const;
 
    MCAPI bool hasTag(::HashedString const& tagName) const;
 
#ifdef LL_PLAT_C
    MCAPI bool isCraftingBlock() const;
 
    MCAPI bool isInteractiveBlock() const;
#endif
 
    MCAPI bool isPartialBlock(::BlockSource const& region, ::BlockPos const& pos) const;
 
    MCAPI bool isPreservingMediumWhenPlaced(::Block const& medium) const;
 
    MCAPI bool isSolidBlockingBlockAndNotSignalSource() const;
 
    MCAPI bool isTopPartialBlock(::BlockSource const& region, ::BlockPos const& pos) const;
 
    MCAPI bool mayPlace(::BlockSource& region, ::BlockPos const& pos, uchar face) const;
 
    MCAPI void neighborChanged(::BlockSource& region, ::BlockPos const& pos, ::BlockPos const& neighborPos) const;
 
    MCAPI void onActorInternalEvent(::BlockPos const& pos, ::std::string const& eventName, ::Actor& sourceEntity) const;
 
    MCAPI void onFallOn(::BlockSource& region, ::BlockPos const& pos, ::Actor& entity, float fallDistance) const;
 
    MCAPI void onPlace(::BlockSource& region, ::BlockPos const& pos, ::Block const& previousBlock) const;
 
    MCAPI void onStateChange(::BlockSource& region, ::BlockPos const& pos, ::Block const& previousBlock) const;
 
    MCAPI void onStepOff(::Actor& entity, ::BlockPos const& pos) const;
 
    MCAPI void onStepOn(::Actor& entity, ::BlockPos const& pos) const;
 
    MCAPI void playerDestroy(::Player& player, ::BlockPos const& pos) const;
 
    MCAPI ::ItemActor*
    popResource(::BlockSource& region, ::BlockPos const& pos, ::ItemInstance const& itemInstance) const;
 
    MCAPI void queuedTick(::BlockSource& region, ::BlockPos const& pos, ::Random& random) const;
 
    MCAPI void randomTick(::BlockSource& region, ::BlockPos const& pos, ::Random& random) const;
 
    MCAPI bool shouldRandomTick() const;
 
    MCAPI void spawnResources(
        ::BlockSource&                region,
        ::BlockPos const&             pos,
        ::IRandom&                    random,
        ::ResourceDropsContext const& resourceDropsContext
    ) const;
 
    MCAPI ::std::string toDebugString() const;
 
    MCAPI bool use(::Player& player, ::BlockPos const& pos, uchar face, ::std::optional<::Vec3> hit) const;
    // NOLINTEND
 
public:
    // static variables
    // NOLINTBEGIN
    MCAPI static ::std::string const& BLOCK_DESCRIPTION_PREFIX();
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor(ushort data, ::gsl::not_null<::BlockType*> oldBlock);
 
    MCAPI void* $ctor(ushort data, ::gsl::not_null<::BlockType*> oldBlock, ::CompoundTag serId, uint const& runId);
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCAPI static void** $vftable();
    // NOLINTEND
};