Scripting: Split Human and Player objects

code/server/CMakeLists.txt

@@ -2,6 +2,7 @@ set(MAFIAMP_SERVER_FILES
     src/main.cpp
     src/core/server.cpp
 
+    src/core/builtins/human.cpp
     src/core/builtins/player.cpp
     src/core/builtins/vehicle.cpp
 

code/server/src/core/builtins/builtins.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include "scripting/engines/node/engine.h"
-#include "scripting/engines/node/sdk.h"
-
 #include "chat.h"
+#include "human.h"
 #include "player.h"
 #include "vehicle.h"
 #include "world.h"
@@ -14,6 +12,7 @@ namespace MafiaMP::Scripting {
         static void Register(v8::Isolate *isolate, v8pp::module *rootModule) {
             Scripting::Chat::Register(isolate, rootModule);
             Scripting::Human::Register(isolate, rootModule);
+            Scripting::Player::Register(isolate, rootModule);
             Scripting::Vehicle::Register(isolate, rootModule);
             Scripting::World::Register(isolate, rootModule);
         }

code/server/src/core/builtins/chat.h

@@ -1,21 +1,34 @@
 #pragma once
 
-#include "scripting/engines/node/engine.h"
-#include "scripting/engines/node/sdk.h"
+#include "core/server.h"
 
 #include "shared/rpc/chat_message.h"
 
 #include "player.h"
 
-#include "core_modules.h"
-
 namespace MafiaMP::Scripting {
     class Chat final {
       public:
+        static void EventChatCommand(flecs::entity e, std::string message, std::string command, std::vector<std::string> args) {
+            const auto engine = MafiaMP::Server::GetNodeEngine();
+            V8_RESOURCE_LOCK(engine);
+            engine->InvokeEvent("chatCommand", Player::WrapPlayer(engine->GetIsolate(), e), message, command, args);
+        }
+
+        static void EventChatMessage(flecs::entity e, std::string message) {
+            const auto engine = MafiaMP::Server::GetNodeEngine();
+            V8_RESOURCE_LOCK(engine);
+            engine->InvokeEvent("chatMessage", Player::WrapPlayer(engine->GetIsolate(), e), message);
+        }
+
+        static void SendToAll(std::string message) {
+            FW_SEND_COMPONENT_RPC(Shared::RPC::ChatMessage, message);
+        }
+
         static void SendToPlayer(Human *human, std::string message) {
             if (human) {
                 const auto ent = human->GetHandle();
-                const auto str   = ent.get<Framework::World::Modules::Base::Streamer>();
+                const auto str = ent.get<Framework::World::Modules::Base::Streamer>();
 
                 if (!str)
                     return;
@@ -24,26 +37,12 @@ namespace MafiaMP::Scripting {
             }
         }
 
-        static void SendToAll(std::string message) {
-            FW_SEND_COMPONENT_RPC(Shared::RPC::ChatMessage, message);
-        }
-
-        static void EventChatMessage(flecs::entity e, std::string message) {
-            const auto engine = MafiaMP::Server::GetNodeEngine();
-            V8_RESOURCE_LOCK(engine);
-            engine->InvokeEvent("chatMessage", Human::WrapHuman(engine, e), message);
-        }
-
-        static void EventChatCommand(flecs::entity e, std::string message, std::string command, std::vector<std::string> args) {
-            const auto engine = MafiaMP::Server::GetNodeEngine();
-            V8_RESOURCE_LOCK(engine);
-            engine->InvokeEvent("chatCommand", Human::WrapHuman(engine, e), message, command, args);
-        }
-
         static void Register(v8::Isolate *isolate, v8pp::module *rootModule) {
             v8pp::module chat(isolate);
-            chat.function("sendToPlayer", &Chat::SendToPlayer);
+
             chat.function("sendToAll", &Chat::SendToAll);
+            chat.function("sendToPlayer", &Chat::SendToPlayer);
+
             rootModule->submodule("Chat", chat);
         }
     };

code/server/src/core/builtins/human.cpp

@@ -0,0 +1,87 @@
+#include "human.h"
+
+#include "shared/game_rpc/add_weapon.h"
+#include "shared/game_rpc/human/human_setprops.h"
+#include "shared/modules/human_sync.hpp"
+
+#include "vehicle.h"
+
+namespace MafiaMP::Scripting {
+    std::string Human::ToString() const {
+        std::ostringstream ss;
+        ss << "Human{ id: " << _ent.id() << " }";
+        return ss.str();
+    }
+
+    void Human::Destroy(v8::Isolate *isolate) {
+        if (_isPlayer) {
+            isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "Player object can not be destroyed!").ToLocalChecked()));
+            return;
+        }
+
+        Entity::Destroy();
+    }
+
+    void Human::AddWeapon(int weaponId, int ammo) {
+        FW_SEND_SERVER_COMPONENT_GAME_RPC(MafiaMP::Shared::RPC::AddWeapon, _ent, weaponId, ammo);
+    }
+
+    v8::Local<v8::Value> Human::GetVehicle(v8::Isolate *isolate) const {
+        const auto updateData = _ent.get<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
+        const auto carEnt     = flecs::entity(_ent.world(), updateData->carPassenger.carId);
+
+        if (carEnt.is_valid() && carEnt.is_alive()) {
+            return Vehicle::WrapVehicle(isolate, carEnt);
+        }
+
+        return v8::Undefined(isolate);
+    }
+
+    int Human::GetVehicleSeat() const {
+        const auto updateData = _ent.get<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
+        const auto carEnt     = flecs::entity(_ent.world(), updateData->carPassenger.carId);
+
+        if (carEnt.is_valid() && carEnt.is_alive()) {
+            return updateData->carPassenger.seatId;
+        }
+
+        return -1;
+    }
+
+    float Human::GetHealth() const {
+        auto h = _ent.get<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
+        return h->_healthPercent;
+    }
+
+    void Human::SetHealth(float health) {
+        auto h            = _ent.get_mut<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
+        h->_healthPercent = health;
+
+        MafiaMP::Shared::RPC::HumanSetProps msg {};
+        msg.health = health;
+        FW_SEND_SERVER_COMPONENT_GAME_RPC(MafiaMP::Shared::RPC::HumanSetProps, _ent, msg);
+    }
+
+    void Human::Register(v8::Isolate *isolate, v8pp::module *rootModule) {
+        if (!rootModule) {
+            return;
+        }
+
+        v8pp::class_<Human> cls(isolate);
+        cls.inherit<Framework::Integrations::Scripting::Entity>();
+        cls.function("addWeapon", &Human::AddWeapon);
+        cls.function("destroy", &Human::Destroy);
+
+        cls.function("getHealth", &Human::GetHealth);
+        cls.function("getVehicle", &Human::GetVehicle);
+        cls.function("getVehicleSeat", &Human::GetVehicleSeat);
+
+        cls.function("setHealth", &Human::SetHealth);
+
+        rootModule->class_("Human", cls);
+    }
+
+    v8::Local<v8::Object> Human::WrapHuman(v8::Isolate *isolate, flecs::entity e) {
+        return v8pp::class_<Scripting::Human>::create_object(isolate, e.id());
+    }
+} // namespace MafiaMP::Scripting

code/server/src/core/builtins/human.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "integrations/server/scripting/builtins/node/entity.h"
+
+namespace MafiaMP::Scripting {
+    class Human: public Framework::Integrations::Scripting::Entity {
+      private:
+        bool _isPlayer = false;
+
+      public:
+        Human(flecs::entity_t ent, bool isPlayer = false): Entity(ent) {
+            _isPlayer = isPlayer;
+        }
+
+        std::string ToString() const override;
+
+        void Destroy(v8::Isolate *isolate);
+
+        void AddWeapon(int weaponId, int ammo);
+
+        v8::Local<v8::Value> GetVehicle(v8::Isolate *isolate) const;
+
+        int GetVehicleSeat() const;
+
+        float GetHealth() const;
+
+        void SetHealth(float health);
+
+        static void Register(v8::Isolate *isolate, v8pp::module *rootModule);
+
+        static v8::Local<v8::Object> WrapHuman(v8::Isolate *isolate, flecs::entity e);
+    };
+} // namespace MafiaMP::Scripting

code/server/src/core/builtins/player.cpp

@@ -1,107 +1,83 @@
 #include "player.h"
 
+#include "core/server.h"
+
 #include "vehicle.h"
 
-#include "shared/modules/human_sync.hpp"
-#include "shared/game_rpc/add_weapon.h"
-#include "shared/game_rpc/human/human_setprops.h"
 #include "shared/rpc/chat_message.h"
 
 namespace MafiaMP::Scripting {
-    v8::Local<v8::Object> Human::WrapHuman(Framework::Scripting::Engines::Node::Engine *engine, flecs::entity e) {
-        return v8pp::class_<Scripting::Human>::create_object(engine->GetIsolate(), e.id());
-    }
-
-    std::string Human::ToString() const {
+    std::string Player::ToString() const {
         std::ostringstream ss;
-        ss << "Human{ id: " << _ent.id() << " }";
+        ss << "Player{ id: " << _ent.id() << " }";
         return ss.str();
     }
 
-    void Human::Destroy(v8::Isolate *isolate) {
-        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "Human object can not be destroyed!").ToLocalChecked()));
+    void Player::EventPlayerConnected(flecs::entity e) {
+        const auto engine = MafiaMP::Server::GetNodeEngine();
+        V8_RESOURCE_LOCK(engine);
+        auto playerObj = WrapPlayer(engine->GetIsolate(), e);
+        engine->InvokeEvent("playerConnected", playerObj);
     }
 
-    void Human::AddWeapon(int weaponId, int ammo) {
-        FW_SEND_SERVER_COMPONENT_GAME_RPC(MafiaMP::Shared::RPC::AddWeapon, _ent, weaponId, ammo);
+    void Player::EventPlayerDisconnected(flecs::entity e) {
+        const auto engine = MafiaMP::Server::GetNodeEngine();
+        V8_RESOURCE_LOCK(engine);
+        auto playerObj = WrapPlayer(engine->GetIsolate(), e);
+        engine->InvokeEvent("playerDisconnected", playerObj);
     }
 
-    void Human::SendChat(std::string message) {
-        const auto str = _ent.get<Framework::World::Modules::Base::Streamer>();
-        FW_SEND_COMPONENT_RPC_TO(Shared::RPC::ChatMessage, SLNet::RakNetGUID(str->guid), message);
+    void Player::EventPlayerDied(flecs::entity e) {
+        const auto engine = MafiaMP::Server::GetNodeEngine();
+        V8_RESOURCE_LOCK(engine);
+        auto playerObj = WrapPlayer(engine->GetIsolate(), e);
+        engine->InvokeEvent("playerDied", playerObj);
     }
 
-    v8::Local<v8::Value> Human::GetVehicle() const {
-        const auto updateData = _ent.get<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
-        const auto carEnt     = flecs::entity(_ent.world(), updateData->carPassenger.carId);
-        if (carEnt.is_valid() && carEnt.is_alive()) {
-            return v8pp::class_<Vehicle>::create_object(v8::Isolate::GetCurrent(), carEnt.id());
-        }
-        return v8::Undefined(v8::Isolate::GetCurrent());
-    }
+    void Player::EventPlayerVehicleEnter(flecs::entity player, flecs::entity vehicle, int seatIndex) {
+        const auto engine = MafiaMP::Server::GetNodeEngine();
+        V8_RESOURCE_LOCK(engine);
 
-    int Human::GetVehicleSeat() const {
-        const auto updateData = _ent.get<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
-        const auto carEnt     = flecs::entity(_ent.world(), updateData->carPassenger.carId);
-        if (carEnt.is_valid() && carEnt.is_alive()) {
-            return updateData->carPassenger.seatId;
-        }
-        return -1;
-    }
+        auto vehicleObj = Vehicle::WrapVehicle(engine->GetIsolate(), vehicle);
+        auto playerObj  = WrapPlayer(engine->GetIsolate(), player);
 
-    void Human::SendChatToAll(std::string message) {
-        FW_SEND_COMPONENT_RPC(Shared::RPC::ChatMessage, message);
+        engine->InvokeEvent("playerVehicleEnter", playerObj, vehicleObj, seatIndex);
     }
 
-    void Human::SetHealth(float health) {
-        auto h            = _ent.get_mut<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
-        h->_healthPercent = health;
-        MafiaMP::Shared::RPC::HumanSetProps msg {};
-        msg.health = health;
-        FW_SEND_SERVER_COMPONENT_GAME_RPC(MafiaMP::Shared::RPC::HumanSetProps, _ent, msg);
-    }
+    void Player::EventPlayerVehicleLeave(flecs::entity player, flecs::entity vehicle) {
+        const auto engine = MafiaMP::Server::GetNodeEngine();
+        V8_RESOURCE_LOCK(engine)
 
-    float Human::GetHealth() const {
-        auto h = _ent.get<MafiaMP::Shared::Modules::HumanSync::UpdateData>();
-        return h->_healthPercent;
-    }
+        auto vehicleObj = Vehicle::WrapVehicle(engine->GetIsolate(), vehicle);
+        auto playerObj  = WrapPlayer(engine->GetIsolate(), player);
 
-    void Human::EventPlayerDied(flecs::entity e) {
-        const auto engine = MafiaMP::Server::GetNodeEngine();
-        V8_RESOURCE_LOCK(engine);
-        auto playerObj = WrapHuman(engine, e);
-        engine->InvokeEvent("playerDied", playerObj);
+        engine->InvokeEvent("playerVehicleLeave", playerObj, vehicleObj);
     }
 
-    void Human::EventPlayerConnected(flecs::entity e) {
-        const auto engine = MafiaMP::Server::GetNodeEngine();
-        V8_RESOURCE_LOCK(engine);
-        auto playerObj = WrapHuman(engine, e);
-        engine->InvokeEvent("playerConnected", playerObj);
+    void Player::SendChat(std::string message) {
+        const auto str = _ent.get<Framework::World::Modules::Base::Streamer>();
+        FW_SEND_COMPONENT_RPC_TO(Shared::RPC::ChatMessage, SLNet::RakNetGUID(str->guid), message);
     }
 
-    void Human::EventPlayerDisconnected(flecs::entity e) {
-        const auto engine = MafiaMP::Server::GetNodeEngine();
-        V8_RESOURCE_LOCK(engine);
-        auto playerObj = WrapHuman(engine, e);
-        engine->InvokeEvent("playerDisconnected", playerObj);
+    void Player::SendChatToAll(std::string message) {
+        FW_SEND_COMPONENT_RPC(Shared::RPC::ChatMessage, message);
     }
 
-    void Human::Register(v8::Isolate *isolate, v8pp::module *rootModule) {
+    void Player::Register(v8::Isolate *isolate, v8pp::module *rootModule) {
         if (!rootModule) {
             return;
         }
 
-        v8pp::class_<Human> cls(isolate);
-        cls.inherit<Framework::Integrations::Scripting::Entity>();
-        cls.function("destroy", &Human::Destroy);
-        cls.function("addWeapon", &Human::AddWeapon);
-        cls.function("setHealth", &Human::SetHealth);
-        cls.function("getHealth", &Human::GetHealth);
-        cls.function("getVehicle", &Human::GetVehicle);
-        cls.function("getVehicleSeat", &Human::GetVehicleSeat);
-        cls.function("sendChat", &Human::SendChat);
-        cls.function("sendChatToAll", &Human::SendChatToAll);
-        rootModule->class_("Human", cls);
+        v8pp::class_<Player> cls(isolate);
+        cls.inherit<MafiaMP::Scripting::Human>();
+
+        cls.function("sendChat", &Player::SendChat);
+        cls.function("sendChatToAll", &Player::SendChatToAll);
+
+        rootModule->class_("Player", cls);
+    }
+
+    v8::Local<v8::Object> Player::WrapPlayer(v8::Isolate *isolate, flecs::entity e) {
+        return v8pp::class_<Scripting::Player>::create_object(isolate, e.id());
     }
-}
+} // namespace MafiaMP::Scripting