feat: adapt to MCBE 1.21.60 (#248)

* feat: adapt some files

* fix: implement AttributeInstance::setCurrentValue in EntityAPI.cpp

* fix: fix EntityClass::getAllTag

* fix: fix EntityAPI completely

* fix: fix some PlayerAPI

* fix: fix some PlayerAPI

* fix: fix Player::addEffect

* fix: fix BaseAPI

* fix: fix BlockAPI(WIP)

* fix: fix BlockAPI
fix: fix #241

* fix: fix BlockEntityAPI

* fix: fix CommandAPI

* fix: fix EventAPI

* fix: fix something

* fix: fix ItemAPI and BlockAPI

* refactor: move BlockHelper to standalone file

* fix: fix PacketAPI

* fix: fix Player's scoreboard API

* fix: fix ScoreboardAPI

* fix: fix ServerAPI

* fix: fix StructureAPI

* fix: fix SimulatedPlayerAPI

* fix: fix BuiltinCommands

* fix: fix SimulatedPlayerHelper.cpp

* fix: fix events except for inlined functions

* chore: update cpp-httplib to 0.18.7

* chore: require openssl3 manually to avoid github actions system package

* chore: try fix mariadb

* chore: update levilamina

* chore: update levilamina

* fix: fix BinaryStreamClass::writeItem

* chore: update levilamina

* chore: update tooth.json and xmake.lua

* fix: fix some events (#247)

* fix:fix some events

Co-authored-by: killcerr <kill_cerr@outlook.com>

* feat: fix AttackBlock event

---------

Co-authored-by: n15421 <119112174+n15421@users.noreply.github.com>

* fix: fix onProjectileHitBlock and onStartDestroyBlock

* fix: fix onOpenContainerScreen

* chore: disable onNpcCmd temporarily

---------

Co-authored-by: killcerr <kill_cerr@outlook.com>
Co-authored-by: n15421 <119112174+n15421@users.noreply.github.com>

Author: 3 people

src/legacy/api/BaseAPI.cpp

@@ -12,9 +12,11 @@
 #include <mc/world/level/BlockSource.h>
 
 ///////////////////// Enum //////////////////////
-ClassDefine<void> DamageCauseEnumBuilder = EnumDefineBuilder<ActorDamageCause>::build("DamageCause");
+ClassDefine<void> DamageCauseEnumBuilder =
+    EnumDefineBuilder<SharedTypes::Legacy::ActorDamageCause>::build("DamageCause");
 // For compatibility
-ClassDefine<void> ActorDamageCauseEnumBuilder = EnumDefineBuilder<ActorDamageCause>::build("ActorDamageCause");
+ClassDefine<void> ActorDamageCauseEnumBuilder =
+    EnumDefineBuilder<SharedTypes::Legacy::ActorDamageCause>::build("ActorDamageCause");
 
 //////////////////// Class Definition ////////////////////
 
@@ -181,7 +183,13 @@ Local<Value> DirectionAngle::toString() {
 
 Local<Value> DirectionAngle::toFacing() {
     int facing = -1;
-    switch (Facing::convertYRotationToFacingDirection(yaw)) {
+    // Facing::convertYRotationToFacingDirection
+    float value  = yaw * 0.011111111f + 0.5f;
+    int   result = static_cast<int>(value) - 1;
+    if (static_cast<float>(static_cast<int>(value)) <= value) {
+        result = static_cast<int>(value);
+    }
+    switch (result) {
     case 2:
         facing = 0;
         break;

src/legacy/api/BlockAPI.cpp

@@ -9,20 +9,25 @@
 #include "api/McAPI.h"
 #include "api/NbtAPI.h"
 #include "ll/api/service/Bedrock.h"
-#include "mc/deps/core/string/HashedString.h"
+#include "lse/api/helper/BlockHelper.h"
 #include "mc/deps/core/utility/optional_ref.h"
 #include "mc/world/level/BlockSource.h"
 #include "mc/world/level/ChunkBlockPos.h"
 #include "mc/world/level/block/BedrockBlockNames.h"
 #include "mc/world/level/block/Block.h"
+#include "mc/world/level/block/DetectionRule.h"
+#include "mc/world/level/block/LiquidReaction.h"
 #include "mc/world/level/block/actor/BlockActor.h"
 #include "mc/world/level/block/block_serialization_utils/BlockSerializationUtils.h"
-#include "mc/world/level/block/components/BlockLiquidDetectionComponent.h"
+#include "mc/world/level/block/components/BlockComponentDirectData.h"
 #include "mc/world/level/chunk/LevelChunk.h"
 #include "mc/world/level/dimension/Dimension.h"
+#include "mc/world/level/dimension/DimensionHeightRange.h"
 
 #include <exception>
 
+using lse::api::BlockHelper;
+
 //////////////////// Class Definition ////////////////////
 
 ClassDefine<BlockClass> BlockClassBuilder =
@@ -66,24 +71,6 @@ ClassDefine<BlockClass> BlockClassBuilder =
         .instanceFunction("getTag", &BlockClass::getNbt)
         .build();
 
-namespace lse::BlockAPI {
-inline bool isValidHeight(WeakRef<Dimension> dim, std::variant<int, float> height) {
-    if (dim) {
-        if (std::holds_alternative<int>(height)) {
-            int y = std::get<int>(height);
-            return dim->getMinHeight() <= y && dim->getHeight() >= y;
-        } else {
-            float y = std::get<float>(height);
-            return dim->getMinHeight() <= y && dim->getHeight() >= y;
-        }
-    }
-
-    return false;
-}
-} // namespace lse::BlockAPI
-
-using lse::BlockAPI::isValidHeight;
-
 //////////////////// Classes ////////////////////
 
 BlockClass::BlockClass(Block const& block) : ScriptClass(ScriptClass::ConstructFromCpp<BlockClass>{}), block(&block) {
@@ -103,8 +90,8 @@ Local<Object> BlockClass::newBlock(Block const& block, BlockPos const& pos, Dime
 }
 
 Local<Object> BlockClass::newBlock(BlockPos const& pos, DimensionType dim) {
-    if (auto dimension = ll::service::getLevel()->getDimension(dim)) {
-        if (isValidHeight(dimension, pos.y)) {
+    if (auto dimension = ll::service::getLevel()->getDimension(dim).lock()) {
+        if (BlockHelper::isValidHeight(dimension, pos.y)) {
             auto& bl = dimension->getBlockSourceFromMainChunkSource().getBlock(pos);
             return BlockClass::newBlock(bl, pos, dim);
         }
@@ -123,8 +110,8 @@ Local<Object> BlockClass::newBlock(Block const& block, BlockPos const& pos, Bloc
 
 Local<Object> BlockClass::newBlock(IntVec4 pos) {
     BlockPos bp = {(float)pos.x, (float)pos.y, (float)pos.z};
-    if (auto dimension = ll::service::getLevel()->getDimension(pos.dim)) {
-        if (isValidHeight(dimension, pos.y)) {
+    if (auto dimension = ll::service::getLevel()->getDimension(pos.dim).lock()) {
+        if (BlockHelper::isValidHeight(dimension, pos.y)) {
             auto& bl = dimension->getBlockSourceFromMainChunkSource().getBlock(bp);
             return BlockClass::newBlock(bl, bp, pos.dim);
         }
@@ -185,28 +172,28 @@ Local<Value> BlockClass::getPos() {
 Local<Value> BlockClass::getTileData() {
     try {
         // preloaded
-        return Number::newNumber(block->getVariant());
+        return Number::newNumber(block->getLegacyBlock().getVariant(*block));
     }
     CATCH("Fail in getTileData!");
 }
 
 Local<Value> BlockClass::getVariant() {
     try {
-        return Number::newNumber(block->getVariant());
+        return Number::newNumber(block->getLegacyBlock().getVariant(*block));
     }
     CATCH("Fail in getVariant!");
 }
 
 Local<Value> BlockClass::getTranslucency() {
     try {
-        return Number::newNumber(block->getTranslucency());
+        return Number::newNumber(block->getLegacyBlock().mTranslucency);
     }
     CATCH("Fail in getTranslucency!");
 }
 
 Local<Value> BlockClass::getThickness() {
     try {
-        return Number::newNumber(block->getThickness());
+        return Number::newNumber(block->getLegacyBlock().mThickness);
     }
     CATCH("Fail in getThickness!");
 }
@@ -220,7 +207,7 @@ Local<Value> BlockClass::isAir() {
 
 Local<Value> BlockClass::isBounceBlock() {
     try {
-        return Boolean::newBoolean(block->isBounceBlock());
+        return Boolean::newBoolean(block->getLegacyBlock().isBounceBlock());
     }
     CATCH("Fail in isBounceBlock!");
 }
@@ -248,35 +235,35 @@ Local<Value> BlockClass::isDoorBlock() {
 
 Local<Value> BlockClass::isFenceBlock() {
     try {
-        return Boolean::newBoolean(block->isFenceBlock());
+        return Boolean::newBoolean(block->getLegacyBlock().isFenceBlock());
     }
     CATCH("Fail in isFenceBlock!");
 }
 
 Local<Value> BlockClass::isFenceGateBlock() {
     try {
-        return Boolean::newBoolean(block->isFenceGateBlock());
+        return Boolean::newBoolean(block->getLegacyBlock().isFenceGateBlock());
     }
     CATCH("Fail in isFenceGateBlock!");
 }
 
 Local<Value> BlockClass::isThinFenceBlock() {
     try {
-        return Boolean::newBoolean(block->isThinFenceBlock());
+        return Boolean::newBoolean(block->getLegacyBlock().isThinFenceBlock());
     }
     CATCH("Fail in isThinFenceBlock!");
 }
 
 Local<Value> BlockClass::isHeavyBlock() {
     try {
-        return Boolean::newBoolean(block->isFallingBlock());
+        return Boolean::newBoolean(block->getLegacyBlock().mFalling);
     }
     CATCH("Fail in isHeavyBlock!");
 }
 
 Local<Value> BlockClass::isStemBlock() {
     try {
-        return Boolean::newBoolean(block->isStemBlock());
+        return Boolean::newBoolean(block->getLegacyBlock().isStemBlock());
     }
     CATCH("Fail in isStemBlock!");
 }
@@ -290,14 +277,17 @@ Local<Value> BlockClass::isSlabBlock() {
 
 Local<Value> BlockClass::isUnbreakable() {
     try {
-        return Boolean::newBoolean(block->isUnbreakable());
+        return Boolean::newBoolean(block->mDirectData->mUnkc08fbd.as<float>() < 0.0f);
     }
     CATCH("Fail in isUnbreakable!");
 }
 
 Local<Value> BlockClass::isWaterBlockingBlock() {
     try {
-        return Boolean::newBoolean(BlockLiquidDetectionComponent::isLiquidBlocking(*block));
+        return Boolean::newBoolean(
+            block->mDirectData->mUnkd3e7c9.as<DetectionRule>().mUnk21e36d.as<LiquidReaction>()
+            == LiquidReaction::Blocking
+        );
     }
     CATCH("Fail in isWaterBlockingBlock!");
 }
@@ -309,7 +299,8 @@ Local<Value> BlockClass::destroyBlock(const Arguments& args) {
     try {
         // same as `Level::getBlockInstance(pos.getBlockPos(),
         // pos.dim).breakNaturally()` when drop
-        BlockSource& bl = ll::service::getLevel()->getDimension(blockPos.dim)->getBlockSourceFromMainChunkSource();
+        BlockSource& bl =
+            ll::service::getLevel()->getDimension(blockPos.dim).lock()->getBlockSourceFromMainChunkSource();
         return Boolean::newBoolean(
             ll::service::getLevel()->destroyBlock(bl, blockPos.getBlockPos(), args[0].asBoolean().value())
         );
@@ -319,7 +310,7 @@ Local<Value> BlockClass::destroyBlock(const Arguments& args) {
 
 Local<Value> BlockClass::getNbt(const Arguments&) {
     try {
-        return NbtCompoundClass::pack(block->getSerializationId().clone());
+        return NbtCompoundClass::pack(block->mSerializationId->clone());
     }
     CATCH("Fail in getNbt!");
 }
@@ -337,6 +328,7 @@ Local<Value> BlockClass::setNbt(const Arguments& args) {
         if (bl) {
             ll::service::getLevel()
                 ->getDimension(blockPos.dim)
+                .lock()
                 ->getBlockSourceFromMainChunkSource()
                 .setBlock(blockPos.getBlockPos(), *bl, 3, nullptr, nullptr);
         }
@@ -347,11 +339,10 @@ Local<Value> BlockClass::setNbt(const Arguments& args) {
 }
 
 Local<Value> BlockClass::getBlockState(const Arguments&) {
-    return Local<Value>();
     try {
-        auto list = block->getSerializationId();
+        auto list = block->mSerializationId;
         try {
-            return Tag2Value(&list.at("states").get(), true);
+            return Tag2Value(&list->at("states").get(), true);
         } catch (...) {
             return Array::newArray();
         }
@@ -365,9 +356,10 @@ Local<Value> BlockClass::hasContainer(const Arguments&) {
     try {
         auto& bl = ll::service::getLevel()
                        ->getDimension(blockPos.dim)
+                       .lock()
                        ->getBlockSourceFromMainChunkSource()
                        .getBlock(blockPos.getBlockPos());
-        return Boolean::newBoolean(bl.isContainerBlock());
+        return Boolean::newBoolean(bl.getLegacyBlock().isContainerBlock());
     }
     CATCH("Fail in hasContainer!");
 }
@@ -376,6 +368,7 @@ Local<Value> BlockClass::getContainer(const Arguments&) {
     try {
         Container* container = ll::service::getLevel()
                                    ->getDimension(blockPos.dim)
+                                   .lock()
                                    ->getBlockSourceFromMainChunkSource()
                                    .getBlockEntity(blockPos.getBlockPos())
                                    ->getContainer();
@@ -386,7 +379,7 @@ Local<Value> BlockClass::getContainer(const Arguments&) {
 
 Local<Value> BlockClass::hasBlockEntity(const Arguments&) {
     try {
-        return Boolean::newBoolean(block->hasBlockEntity());
+        return Boolean::newBoolean(block->getLegacyBlock().mBlockEntityType != BlockActorType::Undefined);
     }
     CATCH("Fail in hasBlockEntity!");
 }
@@ -395,6 +388,7 @@ Local<Value> BlockClass::getBlockEntity(const Arguments&) {
     try {
         BlockActor* be = ll::service::getLevel()
                              ->getDimension(blockPos.dim)
+                             .lock()
                              ->getBlockSourceFromMainChunkSource()
                              .getBlockEntity(blockPos.getBlockPos());
         return be ? BlockEntityClass::newBlockEntity(be, blockPos.dim) : Local<Value>();
@@ -404,11 +398,16 @@ Local<Value> BlockClass::getBlockEntity(const Arguments&) {
 
 Local<Value> BlockClass::removeBlockEntity(const Arguments&) {
     try {
-        ll::service::getLevel()
-            ->getDimension(blockPos.dim)
-            ->getBlockSourceFromMainChunkSource()
-            .removeBlockEntity(blockPos.getBlockPos());
-        return Boolean::newBoolean(true);
+        auto chunk = ll::service::getLevel()
+                         ->getDimension(blockPos.dim)
+                         .lock()
+                         ->getBlockSourceFromMainChunkSource()
+                         .getChunkAt(blockPos.getBlockPos());
+        if (chunk) {
+            return Boolean::newBoolean(chunk->removeBlockEntity(blockPos.getBlockPos()) != nullptr);
+        } else {
+            return Boolean::newBoolean(false);
+        }
     }
     CATCH("Fail in removeBlockEntity!");
 }
@@ -456,23 +455,21 @@ Local<Value> McClass::getBlock(const Arguments& args) {
             return Local<Value>();
         }
 
-        auto dimPtr = ll::service::getLevel()->getDimension(pos.dim).get();
+        auto dimPtr = ll::service::getLevel()->getDimension(pos.dim).lock();
         if (!dimPtr) {
             return {};
         }
         BlockSource& bs        = dimPtr->getBlockSourceFromMainChunkSource();
-        short        minHeight = dimPtr->getMinHeight();
-        if (pos.y < minHeight || pos.y > dimPtr->getHeight()) {
+        short        minHeight = dimPtr->mHeightRange->mMin;
+        if (pos.y < minHeight || pos.y > dimPtr->mHeightRange->mMax) {
             return {};
         }
         auto lc = bs.getChunkAt(pos.getBlockPos());
         if (!lc) {
             return {};
         }
-        ChunkBlockPos cbpos = ChunkBlockPos(pos.getBlockPos(), minHeight);
-        auto&         block = lc->getBlock(cbpos);
-        BlockPos      bp{pos.x, pos.y, pos.z};
-        return BlockClass::newBlock(block, bp, pos.dim);
+        auto& block = lc->getBlock(ChunkBlockPos{(uchar)pos.x, (uchar)pos.z, minHeight});
+        return BlockClass::newBlock(block, pos.getBlockPos(), pos.dim);
     }
     CATCH("Fail in GetBlock!")
 }
@@ -538,7 +535,8 @@ Local<Value> McClass::setBlock(const Arguments& args) {
             if (!bl.has_value()) {
                 return Boolean::newBoolean(false);
             }
-            BlockSource& bs = ll::service::getLevel()->getDimension(pos.dim)->getBlockSourceFromMainChunkSource();
+            BlockSource& bs =
+                ll::service::getLevel()->getDimension(pos.dim).lock()->getBlockSourceFromMainChunkSource();
             return Boolean::newBoolean(bs.setBlock(pos.getBlockPos(), bl, 3, nullptr, nullptr));
         } else if (IsInstanceOf<NbtCompoundClass>(block)) {
             // Nbt
@@ -547,7 +545,8 @@ Local<Value> McClass::setBlock(const Arguments& args) {
             if (!bl.has_value()) {
                 return Boolean::newBoolean(false);
             }
-            BlockSource& bs = ll::service::getLevel()->getDimension(pos.dim)->getBlockSourceFromMainChunkSource();
+            BlockSource& bs =
+                ll::service::getLevel()->getDimension(pos.dim).lock()->getBlockSourceFromMainChunkSource();
             return Boolean::newBoolean(bs.setBlock(pos.getBlockPos(), bl, 3, nullptr, nullptr));
         } else {
             // other block object
@@ -556,7 +555,8 @@ Local<Value> McClass::setBlock(const Arguments& args) {
                 LOG_WRONG_ARG_TYPE(__FUNCTION__);
                 return Local<Value>();
             }
-            BlockSource& bs = ll::service::getLevel()->getDimension(pos.dim)->getBlockSourceFromMainChunkSource();
+            BlockSource& bs =
+                ll::service::getLevel()->getDimension(pos.dim).lock()->getBlockSourceFromMainChunkSource();
             return Boolean::newBoolean(bs.setBlock(pos.getBlockPos(), *bl, 3, nullptr, nullptr));
         }
     }
@@ -620,7 +620,7 @@ Local<Value> McClass::spawnParticle(const Arguments& args) {
         ll::service::getLevel()->spawnParticleEffect(
             type.asString().toString(),
             pos.getVec3(),
-            ll::service::getLevel()->getDimension(pos.dim).get()
+            ll::service::getLevel()->getDimension(pos.dim).lock().get()
         );
         return Boolean::newBoolean(true);
     }