PSE# FOR MYSELF

#pragma once
#include <Scriptables.hpp>
#include <msclr/marshal_cppstd.h>

using namespace System;

#pragma make_public(IPlakScriptable)

namespace PlakMP {
    namespace ManagedTypes {
        static constexpr HPlayer BROADCAST_PLAYER = -1;

        public ref struct PhysicalState
        {
        public:
            Numerics::Vector4 Orientation;
            Numerics::Vector3 Position;

            Numerics::Vector3 LinearVelocity;
            Numerics::Vector3 AngularVelocity;

            float Mass;

            Numerics::Matrix4x4 LocalTransform;
        };

        public ref class Player
        {
        public:
            Player(IPlakScriptable* pScriptable, HPlayer h) : mpScriptable(pScriptable), mHandle(h)
            {
                if (!mpScriptable->PS_IsValidPlayer(mHandle))
                    throw gcnew ArgumentNullException("HPlayer h", "Invalid PlakScriptable player handle");
            }

            property String^ Name {
                String^ get() {
                    return msclr::interop::marshal_as<String^>(std::string(mpScriptable->PS_GetPlayerName(mHandle)));
                }
            }

            property Numerics::Vector3 Position {
                Numerics::Vector3 get() {
                    Vector3 nativePos = mpScriptable->PS_GetPlayerPos(mHandle);
                    return Numerics::Vector3(nativePos.x, nativePos.y, nativePos.z);
                }
            }

            property PhysicalState^ Physics {
                PhysicalState^ get() {
                    PhysicalState^ result = gcnew PhysicalState;
                    RigidBodyData* pRBD = mpScriptable->PS_GetPlayerRBD(mHandle);

                    result->Orientation = Numerics::Vector4(pRBD->Orientation.x, pRBD->Orientation.y, pRBD->Orientation.z, pRBD->Orientation.w);
                    result->Position = Numerics::Vector3(pRBD->Position.x, pRBD->Position.y, pRBD->Position.z);
                    result->AngularVelocity = Numerics::Vector3(pRBD->AngularVelocity.x, pRBD->AngularVelocity.y, pRBD->AngularVelocity.z);
                    result->LinearVelocity = Numerics::Vector3(pRBD->LinearVelocity.x, pRBD->LinearVelocity.y, pRBD->LinearVelocity.z);

                    result->Mass = pRBD->Mass;

                    auto mat = pRBD->Matrix;
                    result->LocalTransform = Numerics::Matrix4x4(
                        mat.m11, mat.m12, mat.m13, mat.m14,
                        mat.m21, mat.m22, mat.m23, mat.m24,
                        mat.m31, mat.m32, mat.m33, mat.m34,
                        mat.m41, mat.m42, mat.m43, mat.m44
                    );

                    return result;
                }
            }

            void Kick(String^ reason)
            {
                mpScriptable->PS_Kick(mHandle, msclr::interop::marshal_as<std::string>(reason).c_str());
            }

            void Ban(String^ reason)
            {
                mpScriptable->PS_Ban(mHandle, msclr::interop::marshal_as<std::string>(reason).c_str());
            }

            void Teleport(Numerics::Vector3 position)
            {
                mpScriptable->PS_TeleportPlayer(mHandle, Vector3(position.X, position.Y, position.Z));
            }

            void Respawn(uint32_t newModelHash)
            {
                mpScriptable->PS_SetCarOverride(mHandle, newModelHash);
            }

            void SendChat(String^ message)
            {
                mpScriptable->PS_SendChat(mHandle, msclr::interop::marshal_as<std::string>(message).c_str());
            }
        private:
            IPlakScriptable* mpScriptable;
            HPlayer mHandle;
        };

        public ref class Server
        {
        public:
            Server(IPlakScriptable* pScriptable)
            {
                mpScriptable = pScriptable;
            }
            void LogWrite(String^ s)
            {
                mpScriptable->PS_LogWrite(msclr::interop::marshal_as<std::string>(s).c_str());
            }
            Player^ GetPlayerByName(String^ name)
            {
                return gcnew Player(mpScriptable, mpScriptable->PS_PlayerByName(msclr::interop::marshal_as<std::string>(name).c_str()));
            }
            void BroadcastChat(String^ message)
            {
                mpScriptable->PS_SendChat(BROADCAST_PLAYER, msclr::interop::marshal_as<std::string>(message).c_str());
            }
        private:
            IPlakScriptable* mpScriptable;
        };

        public interface class IPlakScript
        {
        public:
            void OnScriptInit(Server^ server);
            void OnScriptShutdown();

            void OnPlayerConnect(Player^ player);
            void OnPlayerDisconnect(Player^ player);
            void OnPlayerSpawn(Player^ player);
            void OnPlayerDespawn(Player^ player);
            void OnPlayerUpdate(Player^ player);

            void OnPlayerChatMessage(Player^ player, String^ message);
            void OnPlayerChatCmd(Player^ player, String^ message);
        };

        public ref class BaseScript abstract : public IPlakScript
        {
        public:
            virtual void OnScriptInit(Server^ server) {}
            virtual void OnScriptShutdown() {}

            virtual void OnPlayerConnect(Player^ player) {}
            virtual void OnPlayerDisconnect(Player^ player) {}
            virtual void OnPlayerSpawn(Player^ player) {}
            virtual void OnPlayerDespawn(Player^ player) {}
            virtual void OnPlayerUpdate(Player^ player) {}

            virtual void OnPlayerChatMessage(Player^ player, String^ message) {}
            virtual void OnPlayerChatCmd(Player^ player, String^ message) {}
        };
    }
}