feat: add Actor, Mob, Player class

IceBlcokMC · Jan 11, 2025 · 36aa2c9 · 36aa2c9
1 parent afa343a
commit 36aa2c9
Show file tree

Hide file tree

Showing 10 changed files with 733 additions and 4 deletions.
diff --git a/src/API/ActorAPI.cc b/src/API/ActorAPI.cc
@@ -0,0 +1,168 @@
+#include "ActorAPI.h"
+#include "API/APIHelper.h"
+#include "APIHelper.h"
+#include "Utils/Convert.h"
+#include "Utils/Using.h"
+#include <cstddef>
+#include <sstream>
+
+
+namespace jse {
+
+ClassDefine<ActorAPI> ActorAPI::builder =
+    defineClass<ActorAPI>("Actor")
+        .constructor(nullptr)
+
+        .instanceFunction("toString", &ActorAPI::toString)
+        .instanceFunction("getType", &ActorAPI::getType)
+        .instanceFunction("getRuntimeId", &ActorAPI::getRuntimeId)
+        .instanceFunction("getLocation", &ActorAPI::getLocation)
+        .instanceFunction("getVelocity", &ActorAPI::getVelocity)
+        .instanceFunction("isOnGround", &ActorAPI::isOnGround)
+        .instanceFunction("isInWater", &ActorAPI::isInWater)
+        .instanceFunction("isInLava", &ActorAPI::isInLava)
+        .instanceFunction("getLevel", &ActorAPI::getLevel)
+        .instanceFunction("getDimension", &ActorAPI::getDimension)
+        .instanceFunction("setRotation", &ActorAPI::setRotation)
+        .instanceFunction("teleport", &ActorAPI::teleport)
+        .instanceFunction("getId", &ActorAPI::getId)
+        .instanceFunction("isDead", &ActorAPI::isDead)
+        .instanceFunction("getHealth", &ActorAPI::getHealth)
+        .instanceFunction("getMaxHealth", &ActorAPI::getMaxHealth)
+        .instanceFunction("getScoreboardTags", &ActorAPI::getScoreboardTags)
+        .instanceFunction("addScoreboardTag", &ActorAPI::addScoreboardTag)
+        .instanceFunction("removeScoreboardTag", &ActorAPI::removeScoreboardTag)
+        .instanceFunction("isNameTagVisible", &ActorAPI::isNameTagVisible)
+        .instanceFunction("setNameTagVisible", &ActorAPI::setNameTagVisible)
+        .instanceFunction("isNameTagAlwaysVisible", &ActorAPI::isNameTagAlwaysVisible)
+        .instanceFunction("setNameTagAlwaysVisible", &ActorAPI::setNameTagAlwaysVisible)
+        .instanceFunction("getNameTag", &ActorAPI::getNameTag)
+        .instanceFunction("setNameTag", &ActorAPI::setNameTag)
+        .instanceFunction("getScoreTag", &ActorAPI::getScoreTag)
+        .instanceFunction("setScoreTag", &ActorAPI::setScoreTag)
+
+        // parent class
+        .instanceFunction("asCommandSender", &CommandSenderAPI::asCommandSender)
+        .instanceFunction("asConsole", &CommandSenderAPI::asConsole)
+        .instanceFunction("asActor", &CommandSenderAPI::asActor)
+        .instanceFunction("asPlayer", &CommandSenderAPI::asPlayer)
+        .instanceFunction("sendMessage", &CommandSenderAPI::sendMessage)
+        .instanceFunction("sendErrorMessage", &CommandSenderAPI::sendErrorMessage)
+        .instanceFunction("getServer", &CommandSenderAPI::getServer)
+        .instanceFunction("getName", &CommandSenderAPI::getName)
+
+        .instanceFunction("isOp", &PermissibleAPI::isOP)
+        .instanceFunction("setOp", &PermissibleAPI::setOp)
+        .instanceFunction("isPermissionSet", &PermissibleAPI::isPermissionSet)
+        .instanceFunction("hasPermission", &PermissibleAPI::hasPermission)
+        .instanceFunction("addAttachment", &PermissibleAPI::addAttachment)
+        .instanceFunction("removeAttachment", &PermissibleAPI::removeAttachment)
+        .instanceFunction("recalculatePermissions", &PermissibleAPI::recalculatePermissions)
+        .instanceFunction("getEffectivePermissions", &PermissibleAPI::getEffectivePermissions)
+
+        .build();
+
+
+Local<Value> ActorAPI::toString(Arguments const& args) { return ConvertToScriptX("<Actor>"); }
+
+Local<Value> ActorAPI::getType(Arguments const& args) { return ConvertToScriptX(get()->getType()); }
+
+Local<Value> ActorAPI::getRuntimeId(Arguments const& args) {
+    return ConvertToScriptX(static_cast<int64_t>(get()->getRuntimeId()));
+}
+
+Local<Value> ActorAPI::getLocation(Arguments const& args) { return Local<Value>(); }
+
+Local<Value> ActorAPI::getVelocity(Arguments const& args) { return Local<Value>(); }
+
+Local<Value> ActorAPI::isOnGround(Arguments const& args) { return ConvertToScriptX(get()->isOnGround()); }
+
+Local<Value> ActorAPI::isInWater(Arguments const& args) { return ConvertToScriptX(get()->isInWater()); }
+
+Local<Value> ActorAPI::isInLava(Arguments const& args) { return ConvertToScriptX(get()->isInLava()); }
+
+Local<Value> ActorAPI::getLevel(Arguments const& args) { return Local<Value>(); }
+
+Local<Value> ActorAPI::getDimension(Arguments const& args) { return Local<Value>(); }
+
+Local<Value> ActorAPI::setRotation(Arguments const& args) { return Local<Value>(); }
+
+Local<Value> ActorAPI::teleport(Arguments const& args) { return Local<Value>(); }
+
+Local<Value> ActorAPI::getId(Arguments const& args) { return ConvertToScriptX(get()->getId()); }
+
+Local<Value> ActorAPI::isDead(Arguments const& args) { return ConvertToScriptX(get()->isDead()); }
+
+Local<Value> ActorAPI::getHealth(Arguments const& args) { return ConvertToScriptX(get()->getHealth()); }
+
+Local<Value> ActorAPI::setHealth(Arguments const& args) try {
+    CheckArgsCount(args, 1);
+    CheckArgType(args[0], ValueKind::kNumber);
+    get()->setHealth(args[0].asNumber().toInt64()).value();
+    return Local<Value>();
+}
+Catch;
+
+Local<Value> ActorAPI::getMaxHealth(Arguments const& args) { return ConvertToScriptX(get()->getMaxHealth()); }
+
+Local<Value> ActorAPI::getScoreboardTags(Arguments const& args) { return ConvertToScriptX(get()->getScoreboardTags()); }
+
+Local<Value> ActorAPI::addScoreboardTag(Arguments const& args) try {
+    CheckArgsCount(args, 1);
+    CheckArgType(args[0], ValueKind::kString);
+    return ConvertToScriptX(get()->addScoreboardTag(args[0].asString().toString()));
+}
+Catch;
+
+Local<Value> ActorAPI::removeScoreboardTag(Arguments const& args) try {
+    CheckArgsCount(args, 1);
+    CheckArgType(args[0], ValueKind::kString);
+    return ConvertToScriptX(get()->removeScoreboardTag(args[0].asString().toString()));
+}
+Catch;
+
+Local<Value> ActorAPI::isNameTagVisible(Arguments const& args) {
+    return ConvertToScriptX(get()->isNameTagVisible());
+}
+
+Local<Value> ActorAPI::setNameTagVisible(Arguments const& args) try {
+    CheckArgsCount(args, 1);
+    CheckArgType(args[0], ValueKind::kBoolean);
+    get()->setNameTagVisible(args[0].asBoolean().value());
+    return Local<Value>();
+}
+Catch;
+
+Local<Value> ActorAPI::isNameTagAlwaysVisible(Arguments const& args) {
+    return ConvertToScriptX(get()->isNameTagAlwaysVisible());
+}
+
+Local<Value> ActorAPI::setNameTagAlwaysVisible(Arguments const& args) try {
+    CheckArgsCount(args, 1);
+    CheckArgType(args[0], ValueKind::kBoolean);
+    get()->setNameTagAlwaysVisible(args[0].asBoolean().value());
+    return Local<Value>();
+}
+Catch;
+
+Local<Value> ActorAPI::getNameTag(Arguments const& args) { return String::newString(get()->getNameTag()); }
+
+Local<Value> ActorAPI::setNameTag(Arguments const& args) try {
+    CheckArgsCount(args, 1);
+    CheckArgType(args[0], ValueKind::kString);
+    get()->setNameTag(args[0].asString().toString());
+    return Local<Value>();
+}
+Catch;
+
+Local<Value> ActorAPI::getScoreTag(Arguments const& args) { return String::newString(get()->getScoreTag()); }
+
+Local<Value> ActorAPI::setScoreTag(Arguments const& args) try {
+    CheckArgsCount(args, 1);
+    CheckArgType(args[0], ValueKind::kString);
+    get()->setScoreTag(args[0].asString().toString());
+    return Local<Value>();
+}
+Catch;
+
+} // namespace jse
diff --git a/src/API/ActorAPI.h b/src/API/ActorAPI.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include "API/CommandSenderAPI.h"
+#include "Utils/Defines.h"
+#include "Utils/Using.h"
+#include "endstone/actor/actor.h"
+
+namespace jse {
+
+class ActorAPI : public CommandSenderAPI {
+    endstone::Actor* mActor;
+
+public:
+    template <typename T>
+    explicit ActorAPI(endstone::Actor* actor, ScriptClass::ConstructFromCpp<T> tag)
+    : CommandSenderAPI(actor, tag),
+      mActor(actor) {}
+
+    explicit ActorAPI(endstone::Actor* actor)
+    : CommandSenderAPI(actor, ScriptClass::ConstructFromCpp<ActorAPI>{}),
+      mActor(actor) {}
+
+    static Local<Object> newActorAPI(endstone::Actor* actor) { return (new ActorAPI(actor))->getScriptObject(); }
+
+    endstone::Actor* get() { return mActor; }
+
+    METHODS(toString);
+    METHODS(getType);
+    METHODS(getRuntimeId);
+    METHODS(getLocation); // todo Location类没写
+    METHODS(getVelocity); // todo Velocity类没写
+    METHODS(isOnGround);
+    METHODS(isInWater);
+    METHODS(isInLava);
+    METHODS(getLevel);     // todo Level类没写
+    METHODS(getDimension); // todo Dimension类没写
+    METHODS(setRotation);  // todo Rotation类没写
+    METHODS(teleport);     // todo Location类没写
+    METHODS(getId);
+    METHODS(isDead);
+    METHODS(getHealth);
+    METHODS(setHealth);
+    METHODS(getMaxHealth);
+    METHODS(getScoreboardTags);
+    METHODS(addScoreboardTag);
+    METHODS(removeScoreboardTag);
+    METHODS(isNameTagVisible);
+    METHODS(setNameTagVisible);
+    METHODS(isNameTagAlwaysVisible);
+    METHODS(setNameTagAlwaysVisible);
+    METHODS(getNameTag);
+    METHODS(setNameTag);
+    METHODS(getScoreTag);
+    METHODS(setScoreTag);
+
+    static ClassDefine<ActorAPI> builder;
+};
+
+
+} // namespace jse
diff --git a/src/API/CommandSenderAPI.cc b/src/API/CommandSenderAPI.cc
@@ -1,4 +1,6 @@
 #include "CommandSenderAPI.h"
+#include "ActorAPI.h"
+#include "PlayerAPI.h"
 #include "API/APIHelper.h"
 #include "Utils/Convert.h"
 #include "Utils/Using.h"
@@ -42,9 +44,15 @@ Local<Value> CommandSenderAPI::toString(Arguments const& args) { return ConvertT
 
 Local<Value> CommandSenderAPI::asConsole(Arguments const& args) { return Local<Value>(); }
 
-Local<Value> CommandSenderAPI::asActor(Arguments const& args) { return Local<Value>(); }
+Local<Value> CommandSenderAPI::asActor(Arguments const& args) {
+    if (mSender->asActor() == nullptr) return Local<Value>();
+    return ActorAPI::newActorAPI(mSender->asActor());
+}
 
-Local<Value> CommandSenderAPI::asPlayer(Arguments const& args) { return Local<Value>(); }
+Local<Value> CommandSenderAPI::asPlayer(Arguments const& args) {
+    if (mSender->asPlayer() == nullptr) return Local<Value>();
+    return PlayerAPI::newPlayerAPI(mSender->asPlayer());
+}
 
 Local<Value> CommandSenderAPI::sendMessage(Arguments const& args) {
     try {

diff --git a/src/API/CommandSenderAPI.h b/src/API/CommandSenderAPI.h
@@ -11,7 +11,12 @@ class CommandSenderAPI : public PermissibleAPI {
     endstone::CommandSender* mSender;
 
 public:
-    CommandSenderAPI(endstone::CommandSender* sender)
+    template <typename T>
+    explicit CommandSenderAPI(endstone::CommandSender* sender, ScriptClass::ConstructFromCpp<T> tag)
+    : PermissibleAPI(sender, tag),
+      mSender(sender) {}
+
+    explicit CommandSenderAPI(endstone::CommandSender* sender)
     : PermissibleAPI(sender, ScriptClass::ConstructFromCpp<CommandSenderAPI>{}),
       mSender(sender) {}
 

diff --git a/src/API/MobAPI.cc b/src/API/MobAPI.cc
@@ -0,0 +1,71 @@
+#include "MobAPI.h"
+#include "API/APIHelper.h"
+#include "APIHelper.h"
+#include "Utils/Convert.h"
+#include "Utils/Using.h"
+#include <cstddef>
+#include <sstream>
+
+namespace jse {
+
+ClassDefine<MobAPI> MobAPI::builder =
+    defineClass<MobAPI>("Mob")
+        .constructor(nullptr)
+
+        .instanceFunction("toString", &MobAPI::toString)
+        .instanceFunction("isGliding", &MobAPI::isGliding)
+
+        .instanceFunction("getType", &ActorAPI::getType)
+        .instanceFunction("getRuntimeId", &ActorAPI::getRuntimeId)
+        .instanceFunction("getLocation", &ActorAPI::getLocation)
+        .instanceFunction("getVelocity", &ActorAPI::getVelocity)
+        .instanceFunction("isOnGround", &ActorAPI::isOnGround)
+        .instanceFunction("isInWater", &ActorAPI::isInWater)
+        .instanceFunction("isInLava", &ActorAPI::isInLava)
+        .instanceFunction("getLevel", &ActorAPI::getLevel)
+        .instanceFunction("getDimension", &ActorAPI::getDimension)
+        .instanceFunction("setRotation", &ActorAPI::setRotation)
+        .instanceFunction("teleport", &ActorAPI::teleport)
+        .instanceFunction("getId", &ActorAPI::getId)
+        .instanceFunction("isDead", &ActorAPI::isDead)
+        .instanceFunction("getHealth", &ActorAPI::getHealth)
+        .instanceFunction("getMaxHealth", &ActorAPI::getMaxHealth)
+        .instanceFunction("getScoreboardTags", &ActorAPI::getScoreboardTags)
+        .instanceFunction("addScoreboardTag", &ActorAPI::addScoreboardTag)
+        .instanceFunction("removeScoreboardTag", &ActorAPI::removeScoreboardTag)
+        .instanceFunction("isNameTagVisible", &ActorAPI::isNameTagVisible)
+        .instanceFunction("setNameTagVisible", &ActorAPI::setNameTagVisible)
+        .instanceFunction("isNameTagAlwaysVisible", &ActorAPI::isNameTagAlwaysVisible)
+        .instanceFunction("setNameTagAlwaysVisible", &ActorAPI::setNameTagAlwaysVisible)
+        .instanceFunction("getNameTag", &ActorAPI::getNameTag)
+        .instanceFunction("setNameTag", &ActorAPI::setNameTag)
+        .instanceFunction("getScoreTag", &ActorAPI::getScoreTag)
+        .instanceFunction("setScoreTag", &ActorAPI::setScoreTag)
+
+        // parent class
+        .instanceFunction("asCommandSender", &CommandSenderAPI::asCommandSender)
+        .instanceFunction("asConsole", &CommandSenderAPI::asConsole)
+        .instanceFunction("asActor", &CommandSenderAPI::asActor)
+        .instanceFunction("asPlayer", &CommandSenderAPI::asPlayer)
+        .instanceFunction("sendMessage", &CommandSenderAPI::sendMessage)
+        .instanceFunction("sendErrorMessage", &CommandSenderAPI::sendErrorMessage)
+        .instanceFunction("getServer", &CommandSenderAPI::getServer)
+        .instanceFunction("getName", &CommandSenderAPI::getName)
+
+        .instanceFunction("isOp", &PermissibleAPI::isOP)
+        .instanceFunction("setOp", &PermissibleAPI::setOp)
+        .instanceFunction("isPermissionSet", &PermissibleAPI::isPermissionSet)
+        .instanceFunction("hasPermission", &PermissibleAPI::hasPermission)
+        .instanceFunction("addAttachment", &PermissibleAPI::addAttachment)
+        .instanceFunction("removeAttachment", &PermissibleAPI::removeAttachment)
+        .instanceFunction("recalculatePermissions", &PermissibleAPI::recalculatePermissions)
+        .instanceFunction("getEffectivePermissions", &PermissibleAPI::getEffectivePermissions)
+
+        .build();
+
+
+Local<Value> MobAPI::toString(Arguments const& args) { return ConvertToScriptX("<Mob>"); }
+
+Local<Value> MobAPI::isGliding(Arguments const& args) { return ConvertToScriptX(get()->isGliding()); }
+
+} // namespace jse
diff --git a/src/API/MobAPI.h b/src/API/MobAPI.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "API/ActorAPI.h"
+#include "Utils/Defines.h"
+#include "Utils/Using.h"
+#include "endstone/actor/mob.h"
+
+namespace jse {
+
+class MobAPI : public ActorAPI {
+    endstone::Mob* mMob;
+
+public:
+    template <typename T>
+    explicit MobAPI(endstone::Mob* mob, ScriptClass::ConstructFromCpp<T> tag) : ActorAPI(mob, tag),
+                                                                                mMob(mob) {}
+
+    explicit MobAPI(endstone::Mob* mob) : ActorAPI(mob, ScriptClass::ConstructFromCpp<MobAPI>{}), mMob(mob) {}
+
+    static Local<Object> newMobAPI(endstone::Mob* mob) { return (new MobAPI(mob))->getScriptObject(); }
+
+    endstone::Mob* get() { return mMob; }
+
+    METHODS(toString);
+    METHODS(isGliding);
+
+    static ClassDefine<MobAPI> builder;
+};
+
+
+} // namespace jse