Block.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
#include "mc/world/level/block/BlockProperty.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/world/item/HandSlot.h"
#include "mc/world/level/ShapeType.h"
#include "mc/world/level/block/BlockSupportType.h"
#include "mc/world/level/block/CachedComponentData.h"
#include "mc/world/level/block/components/BlockComponentDirectData.h"
#include "mc/world/level/block/components/BlockComponentStorage.h"
#include "mc/world/level/block/components/ConnectionID.h"
 
// auto generated forward declare list
// clang-format off
class AABB;
class Actor;
class BaseGameVersion;
class BlockChangeContext;
class BlockPos;
class BlockSource;
class BlockState;
class BlockType;
class GetCollisionShapeInterface;
class HashedString;
class HitResult;
class IRandom;
class ItemInstance;
class ItemStackBase;
class Player;
class Random;
class Vec3;
struct BlockAnimateTickData;
struct ResourceDropsContext;
class IClientBlockData;
// 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]] inline bool hasProperty(BlockProperty type) const {
        return static_cast<uint64>(type) & static_cast<uint64>(mBlockType->mProperties);
    }
 
    [[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; }
 
    [[nodiscard]] Material const& getMaterial() const { return getBlockType().mMaterial; }
 
    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; }
 
    template <typename T>
    MCAPI T const* tryGetComponent() const;

    void cacheComponentData() {
        mCachedComponentData->mEmissiveBrightness->mValue = mBlockType->getEmissiveBrightness(*this).mValue;
        mCachedComponentData->mIsSolid                    = _isSolid();
        mCachedComponentData->mOcclusionType              = _getBlockOcclusionType();
    }

    LLNDAPI BlockOcclusionType _getBlockOcclusionType() const;
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 96, ::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
    MCNAPI Block(ushort data, ::gsl::not_null<::BlockType*> oldBlock);
 
    MCNAPI Block(ushort data, ::gsl::not_null<::BlockType*> oldBlock, ::CompoundTag serId, uint const& runId);
 
    MCAPI bool _isSolid() const;
 
#ifdef LL_PLAT_C
    MCNAPI void _playAmbientSounds(::BlockAnimateTickData const& tickData) const;
#endif
 
    MCNAPI void _queueForTickBasedOnComponentConfiguration(
        ::BlockSource&    region,
        ::BlockPos const& pos,
        ::Random&         random,
        bool              placingBlock
    ) const;
 
    MCAPI void _removeFromTickingQueues(::BlockSource& region, ::BlockPos const& pos) const;
 
    MCNAPI ::Block& addTag(::HashedString const& tag);
 
    MCAPI ::ItemInstance asItemInstance(::BlockSource& region, ::BlockPos const& position, bool withData) const;
 
    MCAPI bool breaksFallingBlocks(::BaseGameVersion version) const;
 
    MCNAPI ::std::string buildDescriptionId() const;
 
    MCAPI ::std::string buildDescriptionName() const;
 
    MCNAPI void buildSerializationId(uint latestUpdaterVersion);
 
    MCNAPI bool canConnect(::Block const& connectionBlock, uchar toOther) const;
 
    MCAPI bool canProvideFullSupport(uchar face) const;
 
    MCAPI bool canProvideSupport(uchar face, ::BlockSupportType type) const;
 
    MCAPI bool canSurvive(::BlockSource& region, ::BlockPos const& pos) const;
 
    MCNAPI ::HitResult clip(::BlockPos const& pos, ::Vec3 const& A, ::Vec3 const& B, ::AABB const& aabb) 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& copyState(::Block const& fromBlock, ::BlockState const& state) const;
 
    MCNAPI void executeItemEvent(
        ::ItemStackBase&     item,
        ::std::string const& eventName,
        ::BlockSource&       region,
        ::BlockPos const&    pos,
        ::Actor&             actor,
        ::HandSlot           handSlot
    ) const;
 
    MCAPI void finalizeBlockComponentStorage();
 
    MCNAPI ::std::optional<::ConnectionID> getConnectionID() const;
 
#ifdef LL_PLAT_C
    MCNAPI ::std::string getCraftingLabelText() const;
#endif
 
    MCAPI ::std::string getDescriptionId() const;
 
    MCAPI float getDestroySpeed(::ItemStackBase const& item) const;
 
    MCAPI ::std::string getDisplayName() const;
 
    MCAPI bool hasTag(::HashedString const& tagName) const;
 
    MCAPI bool isCropBlock() const;
 
    MCNAPI bool isPartialBlock(::BlockSource const& region, ::BlockPos const& pos) const;
 
    MCNAPI bool isPreservingMediumWhenPlaced(::Block const& medium) const;
 
    MCNAPI bool isTopPartialBlock(::BlockSource const& region, ::BlockPos const& pos) const;
 
    MCAPI ::Block const& keepStates(::std::vector<::BlockState const*> const& statesToKeep) const;
 
    MCAPI bool mayPlace(::BlockSource& region, ::BlockPos const& pos, uchar face, ::Actor const* placer) const;
 
    MCAPI void neighborChanged(::BlockSource& region, ::BlockPos const& pos, ::BlockPos const& neighborPos) const;
 
    MCNAPI void onActorEvent(::BlockPos const& pos, ::std::string const& eventName, ::Actor& sourceEntity) const;
 
    MCNAPI void
    onActorInternalEvent(::BlockPos const& pos, ::std::string const& eventName, ::Actor& sourceEntity) const;
 
    MCNAPI void onRemove(::BlockSource& region, ::BlockPos const& pos) const;
 
    MCAPI void onStateChange(
        ::BlockSource&              region,
        ::BlockPos const&           pos,
        ::Block const&              previousBlock,
        ::BlockChangeContext const& changeSourceContext
    ) const;
 
    MCAPI void playerDestroy(::Player& player, ::BlockPos const& pos) const;
 
    MCAPI void queuedTick(::BlockSource& region, ::BlockPos const& pos, ::Random& random) const;
 
    MCAPI void randomTick(::BlockSource& region, ::BlockPos const& pos, ::Random& random) const;
 
    MCAPI void spawnResources(
        ::BlockSource&                region,
        ::BlockPos const&             pos,
        ::IRandom&                    random,
        ::ResourceDropsContext const& resourceDropsContext,
        ::Actor const*                actorContext
    ) const;
 
    MCAPI ::std::string toDebugString() const;
 
    MCAPI bool
    use(::Player& player, ::BlockPos const& pos, uchar face, ::HandSlot handSlot, ::std::optional<::Vec3> hit) const;
    // NOLINTEND
 
public:
    // static variables
    // NOLINTBEGIN
    MCAPI static ::std::string const& BLOCK_DESCRIPTION_PREFIX();
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCNAPI void* $ctor(ushort data, ::gsl::not_null<::BlockType*> oldBlock);
 
    MCNAPI void* $ctor(ushort data, ::gsl::not_null<::BlockType*> oldBlock, ::CompoundTag serId, uint const& runId);
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftable();
    // NOLINTEND
};