thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2024-11-08 00:37:15 +01:00
Code Releases Activity

WIP Official plug-in compatibility layer.

Browse Source
This commit is contained in:
Sandu Liviu Catalin 2021-03-15 07:02:48 +02:00
parent aadba58795
commit f02b6be315
12 changed files with 2492 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -7,6 +7,7 @@ set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/vendor/POCO/cmake)
# Several plugin options
option(ENABLE_API21 "Build for 2.1 API." OFF)
option(ENABLE_OFFICIAL "Enable compatibility with official legacy plug-in" ON)
option(FORCE_32BIT_BIN "Create a 32-bit executable binary if the compiler defaults to 64-bit." OFF)
# This option should only be available in certain conditions
if(WIN32 AND MINGW)

17
module/CMakeLists.txt
View File

@ -109,8 +109,17 @@ add_library(SqModule MODULE SqBase.hpp Main.cpp
Logger.cpp Logger.hpp
Register.cpp
)
# Various definitions required by the plugin
# Various definitions required by the plug-in
target_compile_definitions(SqModule PRIVATE SCRAT_USE_EXCEPTIONS=1)
# SDK targeting
if(ENABLE_API21)
target_compile_definitions(SqModule PRIVATE VCMP_SDK_2_1=1)
endif()
# Legacy compatibility with official plug-in
if(ENABLE_OFFICIAL)
target_compile_definitions(SqModule PRIVATE VCMP_ENABLE_OFFICIAL=1)
target_sources(SqModule PRIVATE Misc/Official.cpp Misc/Official.hpp)
endif()
# Link to windows libraries if on windows
if(WIN32 OR MINGW)
target_compile_definitions(SqModule PRIVATE _WIN32_WINNT=0x0601)
@ -124,7 +133,7 @@ target_link_libraries(SqModule Poco::Foundation Poco::Crypto Poco::Data Poco::Ne
if(ENABLE_DATA_SQLITE)
# Link the libraries
target_link_libraries(SqModule Poco::DataSQLite)
# Inform the plugin that it can make use of this library
# Inform the plug-in that it can make use of this library
target_compile_definitions(SqModule PRIVATE SQMOD_POCO_HAS_SQLITE=1)
endif()
# Does POCO have MySLQ support?
@ -132,7 +141,7 @@ find_package(MySQL)
if(MYSQL_FOUND)
# Link the libraries
target_link_libraries(SqModule Poco::DataMySQL)
# Inform the plugin that it can make use of this library
# Inform the plug-in that it can make use of this library
target_compile_definitions(SqModule PRIVATE SQMOD_POCO_HAS_MYSQL=1)
endif()
# Does POCO have PostgreSQL support?
@ -140,7 +149,7 @@ find_package(PostgreSQL)
if(POSTGRESQL_FOUND)
# Link the libraries
target_link_libraries(SqModule Poco::DataPostgreSQL)
# Inform the plugin that it can make use of this library
# Inform the plug-in that it can make use of this library
target_compile_definitions(SqModule PRIVATE SQMOD_POCO_HAS_POSTGRESQL=1)
endif()
# Determine if build mode

272
module/Core.cpp
View File

@ -53,6 +53,20 @@ extern void TerminatePocoData();
// ------------------------------------------------------------------------------------------------
extern Buffer GetRealFilePath(const SQChar * path);
// ------------------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
extern void LgCheckpointSetID(LgCheckpoint * inst, int32_t id);
extern void LgObjectSetID(LgObject * inst, int32_t id);
extern void LgPickupSetID(LgPickup * inst, int32_t id);
extern void LgPlayerSetID(LgPlayer * inst, int32_t id);
extern void LgVehicleSetID(LgVehicle * inst, int32_t id);
extern LightObj LgCheckpointObj(HSQUIRRELVM vm, int32_t id);
extern LightObj LgObjectObj(HSQUIRRELVM vm, int32_t id);
extern LightObj LgPickupObj(HSQUIRRELVM vm, int32_t id);
extern LightObj LgPlayerObj(HSQUIRRELVM vm, int32_t id);
extern LightObj LgVehicleObj(HSQUIRRELVM vm, int32_t id);
#endif
/* ------------------------------------------------------------------------------------------------
* Loader used to process a section from the configuration file and look for scripts to load.
*/
@ -137,6 +151,9 @@ Core Core::s_Inst;
// ------------------------------------------------------------------------------------------------
Core::Core() noexcept
: m_State(0)
#ifdef VCMP_ENABLE_OFFICIAL
, m_Official(false)
#endif
, m_VM(nullptr)
, m_Scripts()
, m_PendingScripts()
@ -219,6 +236,10 @@ bool Core::Initialize()
return false;
}
#ifdef VCMP_ENABLE_OFFICIAL
// See if debugging options should be enabled
m_Official = conf.GetBoolValue("Squirrel", "OfficialCompatibility", m_Official);
#endif
// See if debugging options should be enabled
m_Debugging = conf.GetBoolValue("Squirrel", "Debugging", m_Debugging);
// Configure the empty initialization
@ -1109,6 +1130,16 @@ BlipInst & Core::AllocBlip(int32_t id, bool owned, int32_t header, LightObj & pa
if (!inst.mInst || inst.mObj.IsNull())
{
inst.ResetInstance();
// Make sure that if an instance was created, it points to nothing
if (inst.mInst)
{
inst.mInst->m_ID = -1;
}
// Make sure that if an object was created, it is released
if (!inst.mObj.IsNull())
{
inst.mObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a blip instance for: {}", id);
}
@ -1146,6 +1177,33 @@ CheckpointInst & Core::AllocCheckpoint(int32_t id, bool owned, int32_t header, L
{
return inst; // Return the existing instance
}
#ifdef VCMP_ENABLE_OFFICIAL
// Do we need to support legacy API?
if (IsOfficial())
{
// Create the legacy wrapper object
inst.mLgObj = LgCheckpointObj(m_VM, id);
// Obtain the legacy wrapper instance
inst.mLgInst = inst.mLgObj.CastI< LgCheckpoint >();
// Make sure that both the instance and script object could be created
if (!inst.mLgInst || inst.mLgObj.IsNull())
{
inst.ResetInstance();
// Make sure that if an instance was created, it points to nothing
if (inst.mLgInst)
{
LgCheckpointSetID(inst.mLgInst, -1);
}
// Make sure that if an object was created, it is released
if (!inst.mLgObj.IsNull())
{
inst.mLgObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a checkpoint wrapper instance for: {}", id);
}
}
#endif
// Instantiate the entity manager
DeleteGuard< CCheckpoint > dg(new CCheckpoint(id));
// Create the script object
@ -1158,6 +1216,25 @@ CheckpointInst & Core::AllocCheckpoint(int32_t id, bool owned, int32_t header, L
if (!inst.mInst || inst.mObj.IsNull())
{
inst.ResetInstance();
#ifdef VCMP_ENABLE_OFFICIAL
// Discard legacy wrapper instance
if (IsOfficial())
{
LgCheckpointSetID(inst.mLgInst, -1);
inst.mLgObj.Release();
inst.mLgInst = nullptr;
}
#endif
// Make sure that if an instance was created, it points to nothing
if (inst.mInst)
{
inst.mInst->m_ID = -1;
}
// Make sure that if an object was created, it is released
if (!inst.mObj.IsNull())
{
inst.mObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a checkpoint instance for: {}", id);
}
@ -1207,6 +1284,16 @@ KeyBindInst & Core::AllocKeyBind(int32_t id, bool owned, int32_t header, LightOb
if (!inst.mInst || inst.mObj.IsNull())
{
inst.ResetInstance();
// Make sure that if an instance was created, it points to nothing
if (inst.mInst)
{
inst.mInst->m_ID = -1;
}
// Make sure that if an object was created, it is released
if (!inst.mObj.IsNull())
{
inst.mObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a keybind instance for: {}", id);
}
@ -1244,6 +1331,33 @@ ObjectInst & Core::AllocObject(int32_t id, bool owned, int32_t header, LightObj
{
return inst; // Return the existing instance
}
#ifdef VCMP_ENABLE_OFFICIAL
// Do we need to support legacy API?
if (IsOfficial())
{
// Create the legacy wrapper object
inst.mLgObj = LgObjectObj(m_VM, id);
// Obtain the legacy wrapper instance
inst.mLgInst = inst.mLgObj.CastI< LgObject >();
// Make sure that both the instance and script object could be created
if (!inst.mLgInst || inst.mLgObj.IsNull())
{
inst.ResetInstance();
// Make sure that if an instance was created, it points to nothing
if (inst.mLgInst)
{
LgObjectSetID(inst.mLgInst, -1);
}
// Make sure that if an object was created, it is released
if (!inst.mLgObj.IsNull())
{
inst.mLgObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a object wrapper instance for: {}", id);
}
}
#endif
// Instantiate the entity manager
DeleteGuard< CObject > dg(new CObject(id));
// Create the script object
@ -1256,6 +1370,25 @@ ObjectInst & Core::AllocObject(int32_t id, bool owned, int32_t header, LightObj
if (!inst.mInst || inst.mObj.IsNull())
{
inst.ResetInstance();
#ifdef VCMP_ENABLE_OFFICIAL
// Discard legacy wrapper instance
if (IsOfficial())
{
LgObjectSetID(inst.mLgInst, -1);
inst.mLgObj.Release();
inst.mLgInst = nullptr;
}
#endif
// Make sure that if an instance was created, it points to nothing
if (inst.mInst)
{
inst.mInst->m_ID = -1;
}
// Make sure that if an object was created, it is released
if (!inst.mObj.IsNull())
{
inst.mObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a object instance for: {}", id);
}
@ -1293,6 +1426,33 @@ PickupInst & Core::AllocPickup(int32_t id, bool owned, int32_t header, LightObj
{
return inst; // Return the existing instance
}
#ifdef VCMP_ENABLE_OFFICIAL
// Do we need to support legacy API?
if (IsOfficial())
{
// Create the legacy wrapper object
inst.mLgObj = LgPickupObj(m_VM, id);
// Obtain the legacy wrapper instance
inst.mLgInst = inst.mLgObj.CastI< LgPickup >();
// Make sure that both the instance and script object could be created
if (!inst.mLgInst || inst.mLgObj.IsNull())
{
inst.ResetInstance();
// Make sure that if an instance was created, it points to nothing
if (inst.mLgInst)
{
LgPickupSetID(inst.mLgInst, -1);
}
// Make sure that if an object was created, it is released
if (!inst.mLgObj.IsNull())
{
inst.mLgObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a pickup wrapper instance for: {}", id);
}
}
#endif
// Instantiate the entity manager
DeleteGuard< CPickup > dg(new CPickup(id));
// Create the script object
@ -1305,6 +1465,25 @@ PickupInst & Core::AllocPickup(int32_t id, bool owned, int32_t header, LightObj
if (!inst.mInst || inst.mObj.IsNull())
{
inst.ResetInstance();
#ifdef VCMP_ENABLE_OFFICIAL
// Discard legacy wrapper instance
if (IsOfficial())
{
LgPickupSetID(inst.mLgInst, -1);
inst.mLgObj.Release();
inst.mLgInst = nullptr;
}
#endif
// Make sure that if an instance was created, it points to nothing
if (inst.mInst)
{
inst.mInst->m_ID = -1;
}
// Make sure that if an object was created, it is released
if (!inst.mObj.IsNull())
{
inst.mObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a pickup instance for: {}", id);
}
@ -1342,6 +1521,33 @@ VehicleInst & Core::AllocVehicle(int32_t id, bool owned, int32_t header, LightOb
{
return inst; // Return the existing instance
}
#ifdef VCMP_ENABLE_OFFICIAL
// Do we need to support legacy API?
if (IsOfficial())
{
// Create the legacy wrapper object
inst.mLgObj = LgVehicleObj(m_VM, id);
// Obtain the legacy wrapper instance
inst.mLgInst = inst.mLgObj.CastI< LgVehicle >();
// Make sure that both the instance and script object could be created
if (!inst.mLgInst || inst.mLgObj.IsNull())
{
inst.ResetInstance();
// Make sure that if an instance was created, it points to nothing
if (inst.mLgInst)
{
LgVehicleSetID(inst.mLgInst, -1);
}
// Make sure that if an object was created, it is released
if (!inst.mLgObj.IsNull())
{
inst.mLgObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a vehicle wrapper instance for: {}", id);
}
}
#endif
// Instantiate the entity manager
DeleteGuard< CVehicle > dg(new CVehicle(id));
// Create the script object
@ -1354,6 +1560,25 @@ VehicleInst & Core::AllocVehicle(int32_t id, bool owned, int32_t header, LightOb
if (!inst.mInst || inst.mObj.IsNull())
{
inst.ResetInstance();
#ifdef VCMP_ENABLE_OFFICIAL
// Discard legacy wrapper instance
if (IsOfficial())
{
LgVehicleSetID(inst.mLgInst, -1);
inst.mLgObj.Release();
inst.mLgInst = nullptr;
}
#endif
// Make sure that if an instance was created, it points to nothing
if (inst.mInst)
{
inst.mInst->m_ID = -1;
}
// Make sure that if an object was created, it is released
if (!inst.mObj.IsNull())
{
inst.mObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a vehicle instance for: {}", id);
}
@ -1732,6 +1957,33 @@ void Core::ConnectPlayer(int32_t id, int32_t header, LightObj & payload)
{
return; // Nothing to allocate!
}
#ifdef VCMP_ENABLE_OFFICIAL
// Do we need to support legacy API?
if (IsOfficial())
{
// Create the legacy wrapper object
inst.mLgObj = LgPlayerObj(m_VM, id);
// Obtain the legacy wrapper instance
inst.mLgInst = inst.mLgObj.CastI< LgPlayer >();
// Make sure that both the instance and script object could be created
if (!inst.mLgInst || inst.mLgObj.IsNull())
{
inst.ResetInstance();
// Make sure that if an instance was created, it points to nothing
if (inst.mLgInst)
{
LgPlayerSetID(inst.mLgInst, -1);
}
// Make sure that if an object was created, it is released
if (!inst.mLgObj.IsNull())
{
inst.mLgObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a player wrapper instance for: {}", id);
}
}
#endif
// Instantiate the entity manager
DeleteGuard< CPlayer > dg(new CPlayer(id));
// Create the script object
@ -1744,6 +1996,26 @@ void Core::ConnectPlayer(int32_t id, int32_t header, LightObj & payload)
if (!inst.mInst || inst.mObj.IsNull())
{
inst.ResetInstance();
#ifdef VCMP_ENABLE_OFFICIAL
// Discard legacy wrapper instance
if (IsOfficial())
{
LgPlayerSetID(inst.mLgInst, -1);
inst.mLgObj.Release();
inst.mLgInst = nullptr;
}
#endif
// Make sure that if an instance was created, it points to nothing
if (inst.mInst)
{
inst.mInst->m_ID = -1;
}
// Make sure that if an object was created, it is released
if (!inst.mObj.IsNull())
{
inst.mObj.Release();
}
// Now we can throw the error
STHROWF("Unable to create a player instance for: {}", id);
}
// Assign the specified entity identifier

16
module/Core.hpp
View File

@ -61,6 +61,9 @@ private:
// --------------------------------------------------------------------------------------------
int32_t m_State; // Current plug-in state.
#ifdef VCMP_ENABLE_OFFICIAL
bool m_Official; // Whether official support is enabked.
#endif
HSQUIRRELVM m_VM; // Script virtual machine.
Scripts m_Scripts; // Loaded scripts objects.
Scripts m_PendingScripts; // Pending scripts objects.
@ -181,6 +184,16 @@ public:
return m_State;
}
#ifdef VCMP_ENABLE_OFFICIAL
/* --------------------------------------------------------------------------------------------
* See whether official support option was enabled in the plug-in.
*/
SQMOD_NODISCARD bool IsOfficial() const
{
return m_Official;
}
#endif
/* --------------------------------------------------------------------------------------------
* See whether debugging option was enabled in the plug-in.
*/
@ -471,6 +484,7 @@ public:
SQMOD_NODISCARD BlipInst & GetBlip(int32_t id) { return m_Blips.at(static_cast< size_t >(id)); }
SQMOD_NODISCARD CheckpointInst & GetCheckpoint(int32_t id) { return m_Checkpoints.at(static_cast< size_t >(id)); }
SQMOD_NODISCARD KeyBindInst & GetKeyBind(int32_t id) { return m_KeyBinds.at(static_cast< size_t >(id)); }
// Windows API is retarded. That's why this isn't named `GetObject` like the others
SQMOD_NODISCARD ObjectInst & GetObj(int32_t id) { return m_Objects.at(static_cast< size_t >(id)); }
SQMOD_NODISCARD PickupInst & GetPickup(int32_t id) { return m_Pickups.at(static_cast< size_t >(id)); }
SQMOD_NODISCARD PlayerInst & GetPlayer(int32_t id) { return m_Players.at(static_cast< size_t >(id)); }
@ -556,7 +570,7 @@ public:
void EmitPlayerRequestClass(int32_t player_id, int32_t offset);
void EmitPlayerRequestSpawn(int32_t player_id);
void EmitPlayerSpawn(int32_t player_id);
void EmitPlayerWasted(int32_t player_id, int32_t reason);
void EmitPlayerWasted(int32_t player_id, int32_t reason, vcmpBodyPart body_part);
void EmitPlayerKilled(int32_t player_id, int32_t killer_id, int32_t reason, vcmpBodyPart body_part, bool team_kill);
void EmitPlayerEmbarking(int32_t player_id, int32_t vehicle_id, int32_t slot_index);
void EmitPlayerEmbarked(int32_t player_id, int32_t vehicle_id, int32_t slot_index);

69
module/Core/Entity.cpp
View File

@ -32,6 +32,15 @@ namespace SqMod {
// ------------------------------------------------------------------------------------------------
extern void CleanupTasks(int32_t id, int32_t type);
// ------------------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
extern void LgCheckpointSetID(LgCheckpoint * inst, int32_t id);
extern void LgObjectSetID(LgObject * inst, int32_t id);
extern void LgPickupSetID(LgPickup * inst, int32_t id);
extern void LgPlayerSetID(LgPlayer * inst, int32_t id);
extern void LgVehicleSetID(LgVehicle * inst, int32_t id);
#endif
// ------------------------------------------------------------------------------------------------
BlipInst::~BlipInst()
{
@ -161,6 +170,18 @@ void CheckpointInst::Destroy(bool destroy, int32_t header, LightObj & payload)
mInst = nullptr;
// Release the script object, if any
mObj.Release();
#ifdef VCMP_ENABLE_OFFICIAL
// Is there a manager instance associated with this entity?
if (mLgInst)
{
// Prevent further use of this entity
LgCheckpointSetID(mLgInst, -1);
}
// Prevent further use of the manager instance
mLgInst = nullptr;
// Release the script object, if any
mLgObj.Release();
#endif
// Release tasks, if any
CleanupTasks(mID, ENT_CHECKPOINT);
// Are we supposed to clean up this entity? (only at reload)
@ -243,6 +264,18 @@ void ObjectInst::Destroy(bool destroy, int32_t header, LightObj & payload)
mInst = nullptr;
// Release the script object, if any
mObj.Release();
#ifdef VCMP_ENABLE_OFFICIAL
// Is there a manager instance associated with this entity?
if (mLgInst)
{
// Prevent further use of this entity
LgObjectSetID(mLgInst, -1);
}
// Prevent further use of the manager instance
mLgInst = nullptr;
// Release the script object, if any
mLgObj.Release();
#endif
// Release tasks, if any
CleanupTasks(mID, ENT_OBJECT);
// Are we supposed to clean up this entity? (only at reload)
@ -284,6 +317,18 @@ void PickupInst::Destroy(bool destroy, int32_t header, LightObj & payload)
mInst = nullptr;
// Release the script object, if any
mObj.Release();
#ifdef VCMP_ENABLE_OFFICIAL
// Is there a manager instance associated with this entity?
if (mLgInst)
{
// Prevent further use of this entity
LgPickupSetID(mLgInst, -1);
}
// Prevent further use of the manager instance
mLgInst = nullptr;
// Release the script object, if any
mLgObj.Release();
#endif
// Release tasks, if any
CleanupTasks(mID, ENT_PICKUP);
// Are we supposed to clean up this entity? (only at reload)
@ -327,6 +372,18 @@ void PlayerInst::Destroy(bool /*destroy*/, int32_t header, LightObj & payload)
mInst = nullptr;
// Release the script object, if any
mObj.Release();
#ifdef VCMP_ENABLE_OFFICIAL
// Is there a manager instance associated with this entity?
if (mLgInst)
{
// Prevent further use of this entity
LgPlayerSetID(mLgInst, -1);
}
// Prevent further use of the manager instance
mLgInst = nullptr;
// Release the script object, if any
mLgObj.Release();
#endif
// Release tasks, if any
CleanupTasks(mID, ENT_PLAYER);
// Reset the instance to it's initial state
@ -360,6 +417,18 @@ void VehicleInst::Destroy(bool destroy, int32_t header, LightObj & payload)
mInst = nullptr;
// Release the script object, if any
mObj.Release();
#ifdef VCMP_ENABLE_OFFICIAL
// Is there a manager instance associated with this entity?
if (mLgInst)
{
// Prevent further use of this entity
LgVehicleSetID(mLgInst, -1);
}
// Prevent further use of the manager instance
mLgInst = nullptr;
// Release the script object, if any
mLgObj.Release();
#endif
// Release tasks, if any
CleanupTasks(mID, ENT_VEHICLE);
// Are we supposed to clean up this entity? (only at reload)

39
module/Core/Entity.hpp
View File

@ -15,6 +15,15 @@ namespace SqMod {
// --------------------------------------------------------------------------------------------
typedef std::vector< std::pair< Area *, LightObj > > AreaList; // List of collided areas.
// --------------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
struct LgCheckpoint;
struct LgObject;
struct LgPickup;
struct LgPlayer;
struct LgVehicle;
#endif
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify a blip entity instance on the server.
*/
@ -118,6 +127,12 @@ struct CheckpointInst
// ----------------------------------------------------------------------------------------
LightObj mEvents{}; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
LgCheckpoint * mLgInst{nullptr}; // Pointer to the actual instance used to interact this entity.
LightObj mLgObj{}; // Script object of the instance used to interact this entity.
#endif
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed{};
SignalPair mOnCustom{};
@ -234,6 +249,12 @@ struct ObjectInst
// ----------------------------------------------------------------------------------------
LightObj mEvents{}; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
LgObject * mLgInst{nullptr}; // Pointer to the actual instance used to interact this entity.
LightObj mLgObj{}; // Script object of the instance used to interact this entity.
#endif
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed{};
SignalPair mOnCustom{};
@ -292,6 +313,12 @@ struct PickupInst
// ----------------------------------------------------------------------------------------
LightObj mEvents{}; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
LgPickup * mLgInst{nullptr}; // Pointer to the actual instance used to interact this entity.
LightObj mLgObj{}; // Script object of the instance used to interact this entity.
#endif
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed{};
SignalPair mOnCustom{};
@ -379,6 +406,12 @@ struct PlayerInst
// ----------------------------------------------------------------------------------------
LightObj mEvents{}; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
LgPlayer * mLgInst{nullptr}; // Pointer to the actual instance used to interact this entity.
LightObj mLgObj{}; // Script object of the instance used to interact this entity.
#endif
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed{};
SignalPair mOnCustom{};
@ -523,6 +556,12 @@ struct VehicleInst
// ----------------------------------------------------------------------------------------
LightObj mEvents{}; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
LgVehicle * mLgInst{nullptr}; // Pointer to the actual instance used to interact this entity.
LightObj mLgObj{}; // Script object of the instance used to interact this entity.
#endif
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed{};
SignalPair mOnCustom{};

398
module/Core/Events.inc
View File

@ -4,6 +4,47 @@ namespace SqMod {
// ------------------------------------------------------------------------------------------------
#define NULL_SQOBJ_(o) (o.IsNull() ? "NULL" : "OBJ")
// ------------------------------------------------------------------------------------------------
#ifdef VCMP_ENABLE_OFFICIAL
// ------------------------------------------------------------------------------------------------
// Invoke a script function from the root table with no return value
template < class... Args > static void ExecuteLegacyEvent(HSQUIRRELVM vm, const SQChar * name, Args &&... args)
{
StackGuard sqsg(vm);
// Push the root table on the stack
sq_pushroottable(vm);
// Grab the function from the table
Function fn(vm, sq_gettop(vm), name);
// Was there a callback with that name?
if (fn.IsNull())
{
return; // Nothing to invoke
}
// Forward the call to the function
fn.Execute(std::forward< Args >(args)...);
}
// ------------------------------------------------------------------------------------------------
// Invoke a script function from the root table with a return value
template < class... Args > static LightObj EvaluateLegacyEvent(HSQUIRRELVM vm, const SQChar * name, Args &&... args)
{
StackGuard sqsg(vm);
// Push the root table on the stack
sq_pushroottable(vm);
// Grab the function from the table
Function fn(vm, sq_gettop(vm), name);
// Was there a callback with that name?
if (fn.IsNull())
{
return LightObj{}; // Nothing to invoke
}
// Forward the call to the function
return fn.Eval(std::forward< Args >(args)...);
}
// ------------------------------------------------------------------------------------------------
static int32_t g_LastHour = 0;
static int32_t g_LastMinute = 0;
#endif
// ------------------------------------------------------------------------------------------------
void Core::EmitCustomEvent(int32_t group, int32_t header, LightObj & payload) const
{
@ -58,6 +99,12 @@ void Core::EmitPlayerCreated(int32_t player, int32_t header, LightObj & payload)
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::PlayerCreated(%d, %d, %s)", player, header, NULL_SQOBJ_(payload))
(*mOnPlayerCreated.first)(m_Players.at(static_cast< size_t >(player)).mObj, header, payload);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerCreated")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerJoin"), m_Players.at(static_cast< size_t >(player)).mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -126,6 +173,12 @@ void Core::EmitPlayerDestroyed(int32_t player, int32_t header, LightObj & payloa
(*_player.mOnDestroyed.first)(header, payload);
(*mOnPlayerDestroyed.first)(_player.mObj, header, payload);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerDestroyed")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerPart"), _player.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -214,6 +267,12 @@ void Core::EmitServerStartup() const
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::ServerStartup()")
(*mOnServerStartup.first)();
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ServerStartup")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onServerStart"));
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -222,6 +281,13 @@ void Core::EmitServerShutdown() const
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::ServerShutdown()")
(*mOnServerShutdown.first)();
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ServerShutdown")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onServerStop"));
ExecuteLegacyEvent(m_VM, _SC("onScriptUnload"));
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -230,6 +296,20 @@ void Core::EmitServerFrame(float elapsed_time) const
//SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::ServerFrame(%f)", elapsed_time)
(*mOnServerFrame.first)(elapsed_time);
//SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ServerFrame")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
const int32_t hour = _Func->GetHour(), minute = _Func->GetMinute();
// Check for onTimeChange triggers
if(g_LastHour != hour || g_LastMinute != minute)
{
ExecuteLegacyEvent(m_VM, _SC("onTimeChange"), g_LastHour, g_LastMinute, hour, minute);
// Update values
g_LastHour = hour;
g_LastMinute = minute;
}
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -253,11 +333,14 @@ void Core::EmitIncomingConnection(char * player_name, size_t name_buffer_size, c
// Save the buffer information so that we can write to it from the string
m_IncomingNameBuffer = player_name;
m_IncomingNameCapacity = name_buffer_size;
// Create reusable objects from parameters
LightObj player_name_obj(player_name, -1);
LightObj user_password_obj(user_password, -1);
LightObj ip_address_obj(ip_address, -1);
// Attempt to forward the event to the script callback
try
{
(*mOnIncomingConnection.first)(LightObj(player_name, -1), name_buffer_size,
LightObj(user_password, -1), LightObj(ip_address, -1));
(*mOnIncomingConnection.first)(player_name_obj, name_buffer_size, user_password_obj, ip_address_obj);
}
catch (...)
{
@ -271,6 +354,13 @@ void Core::EmitIncomingConnection(char * player_name, size_t name_buffer_size, c
m_IncomingNameBuffer = nullptr;
m_IncomingNameCapacity = 0;
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::IncomingConnection")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
LightObj r = EvaluateLegacyEvent(m_VM, _SC("onLoginAttempt"), player_name_obj, user_password_obj, ip_address_obj);
SetState(r.IsNull() ? 1 : r.Cast< int32_t >());
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -281,6 +371,14 @@ void Core::EmitPlayerRequestClass(int32_t player_id, int32_t offset)
(*_player.mOnRequestClass.first)(offset);
(*mOnPlayerRequestClass.first)(_player.mObj, offset);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerRequestClass")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
LightObj r = EvaluateLegacyEvent(m_VM, _SC("onPlayerRequestClass"),
_player.mLgObj, offset, _Func->GetPlayerTeam(player_id), _Func->GetPlayerSkin(player_id));
SetState(r.IsNull() ? 1 : r.Cast< int32_t >());
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -291,6 +389,12 @@ void Core::EmitPlayerRequestSpawn(int32_t player_id)
(*_player.mOnRequestSpawn.first)();
(*mOnPlayerRequestSpawn.first)(_player.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerRequestSpawn")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerRequestSpawn"), _player.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -301,16 +405,31 @@ void Core::EmitPlayerSpawn(int32_t player_id)
(*_player.mOnSpawn.first)();
(*mOnPlayerSpawn.first)(_player.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerSpawn")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerSpawn"), _player.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
void Core::EmitPlayerWasted(int32_t player_id, int32_t reason)
void Core::EmitPlayerWasted(int32_t player_id, int32_t reason, vcmpBodyPart SQ_UNUSED_ARG(body_part))
{
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::PlayerWasted(%d, %d)", player_id, reason)
PlayerInst & _player = m_Players.at(static_cast< size_t >(player_id));
(*_player.mOnWasted.first)(reason);
(*mOnPlayerWasted.first)(_player.mObj, reason);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerWasted")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
if (reason == 43 || reason == 50) reason = 43; // drowned
else if (reason == 39 && body_part == 7) reason = 39; // car crash
else if (reason == 39 || reason == 40 || reason == 44) reason = 44; // fell
ExecuteLegacyEvent(m_VM, _SC("onPlayerDeath"), _player.mLgObj, reason);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -322,6 +441,19 @@ void Core::EmitPlayerKilled(int32_t player_id, int32_t killer_id, int32_t reason
(*_player.mOnKilled.first)(_killer.mObj, reason, static_cast< int32_t >(body_part), team_kill);
(*mOnPlayerKilled.first)(_player.mObj, _killer.mObj, reason, static_cast< int32_t >(body_part), team_kill);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerKilled")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
if (!team_kill)
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerTeamKill"), _killer.mLgObj, _player.mLgObj, reason, static_cast< int32_t >(body_part));
}
else
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerKill"), _killer.mLgObj, _player.mLgObj, reason, static_cast< int32_t >(body_part));
}
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -334,6 +466,14 @@ void Core::EmitPlayerEmbarking(int32_t player_id, int32_t vehicle_id, int32_t sl
(*_vehicle.mOnEmbarking.first)(_player.mObj, slot_index);
(*mOnPlayerEmbarking.first)(_player.mObj, _vehicle.mObj, slot_index);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerEmbarking")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
LightObj r = EvaluateLegacyEvent(m_VM, _SC("onPlayerEnteringVehicle"),
_player.mLgObj, _vehicle.mLgObj, slot_index);
SetState(r.IsNull() ? 1 : r.Cast< int32_t >());
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -346,6 +486,12 @@ void Core::EmitPlayerEmbarked(int32_t player_id, int32_t vehicle_id, int32_t slo
(*_vehicle.mOnEmbarked.first)(_player.mObj, slot_index);
(*mOnPlayerEmbarked.first)(_player.mObj, _vehicle.mObj, slot_index);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerEmbarked")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerEnterVehicle"), _player.mLgObj, _vehicle.mLgObj, slot_index);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -358,6 +504,12 @@ void Core::EmitPlayerDisembark(int32_t player_id, int32_t vehicle_id)
(*_vehicle.mOnDisembark.first)(_player.mObj);
(*mOnPlayerDisembark.first)(_player.mObj, _vehicle.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerDisembark")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerExitVehicle"), _player.mLgObj, _vehicle.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -369,6 +521,12 @@ void Core::EmitPlayerRename(int32_t player_id, const char * old_name, const char
(*_player.mOnRename.first)(oname, nname);
(*mOnPlayerRename.first)(_player.mObj, oname, nname);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerRename")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerNameChange"), _player.mLgObj, oname, nname);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -379,6 +537,12 @@ void Core::EmitPlayerState(int32_t player_id, int32_t old_state, int32_t new_sta
(*_player.mOnState.first)(old_state, new_state);
(*mOnPlayerState.first)(_player.mObj, old_state, new_state);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerState")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerActionChange"), _player.mLgObj, old_state, new_state);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -479,6 +643,12 @@ void Core::EmitPlayerAction(int32_t player_id, int32_t old_action, int32_t new_a
(*_player.mOnAction.first)(old_action, new_action);
(*mOnPlayerAction.first)(_player.mObj, old_action, new_action);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerAction")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerActionChange"), _player.mLgObj, old_action, new_action);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -619,6 +789,12 @@ void Core::EmitPlayerBurning(int32_t player_id, bool is_on_fire)
(*_player.mOnBurning.first)(is_on_fire);
(*mOnPlayerBurning.first)(_player.mObj, is_on_fire);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerBurning")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerOnFireChange"), _player.mLgObj, is_on_fire);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -629,6 +805,12 @@ void Core::EmitPlayerCrouching(int32_t player_id, bool is_crouching)
(*_player.mOnCrouching.first)(is_crouching);
(*mOnPlayerCrouching.first)(_player.mObj, is_crouching);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerCrouching")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerCrouchChange"), _player.mLgObj, is_crouching);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -639,6 +821,12 @@ void Core::EmitPlayerGameKeys(int32_t player_id, uint32_t old_keys, uint32_t new
(*_player.mOnGameKeys.first)(old_keys, new_keys);
(*mOnPlayerGameKeys.first)(_player.mObj, old_keys, new_keys);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerGameKeys")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerGameKeysChange"), _player.mLgObj, old_keys, new_keys);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -649,6 +837,12 @@ void Core::EmitPlayerStartTyping(int32_t player_id)
(*_player.mOnStartTyping.first)();
(*mOnPlayerStartTyping.first)(_player.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerStartTyping")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerBeginTyping"), _player.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -659,6 +853,12 @@ void Core::EmitPlayerStopTyping(int32_t player_id)
(*_player.mOnStopTyping.first)();
(*mOnPlayerStopTyping.first)(_player.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerStopTyping")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerEndTyping"), _player.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -669,6 +869,12 @@ void Core::EmitPlayerAway(int32_t player_id, bool is_away)
(*_player.mOnAway.first)(is_away);
(*mOnPlayerAway.first)(_player.mObj, is_away);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerAway")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerAwayChange"), _player.mLgObj, is_away);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -680,6 +886,13 @@ void Core::EmitPlayerMessage(int32_t player_id, const char * message)
(*_player.mOnMessage.first)(msg);
(*mOnPlayerMessage.first)(_player.mObj, msg);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerMessage")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
LightObj r = EvaluateLegacyEvent(m_VM, _SC("onPlayerChat"), _player.mLgObj, msg);
SetState(r.IsNull() ? 1 : r.Cast< int32_t >());
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -691,6 +904,31 @@ void Core::EmitPlayerCommand(int32_t player_id, const char * message)
(*_player.mOnCommand.first)(msg);
(*mOnPlayerCommand.first)(_player.mObj, msg);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerCommand")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
LightObj text, args;
// Find the first space character
const char * split = std::strchr(message, ' ');
// Do we need to split the command from arguments?
if (split)
{
// Create a string object for the command (don't include the space character)
text = LightObj(message, static_cast< SQInteger >(split - message) - 1);
// Do we need to create a script object for arguments?
if (std::strlen(split + 1) > 0)
{
args = LightObj(split + 1, -1); // Skip the space character
}
}
else
{
text = std::move(msg); // Use the existing message object as is
}
LightObj r = EvaluateLegacyEvent(m_VM, _SC("onPlayerCommand"), _player.mLgObj, text, args);
SetState(r.IsNull() ? 1 : r.Cast< int32_t >());
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -703,6 +941,13 @@ void Core::EmitPlayerPrivateMessage(int32_t player_id, int32_t target_player_id,
(*_player.mOnMessage.first)(_receiver.mObj, msg);
(*mOnPlayerPrivateMessage.first)(_player.mObj, _receiver.mObj, msg);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerPrivateMessage")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
LightObj r = EvaluateLegacyEvent(m_VM, _SC("onPlayerPM"), _player.mLgObj, _receiver.mLgObj, msg);
SetState(r.IsNull() ? 1 : r.Cast< int32_t >());
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -715,6 +960,12 @@ void Core::EmitPlayerKeyPress(int32_t player_id, int32_t bind_id)
(*_keybind.mOnKeyPress.first)(_player.mObj);
(*mOnPlayerKeyPress.first)(_player.mObj, _keybind.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerKeyPress")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onKeyDown"), _player.mLgObj, bind_id);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -727,6 +978,12 @@ void Core::EmitPlayerKeyRelease(int32_t player_id, int32_t bind_id)
(*_player.mOnKeyRelease.first)(_keybind.mObj);
(*mOnPlayerKeyRelease.first)(_player.mObj, _keybind.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerKeyRelease")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onKeyUp"), _player.mLgObj, bind_id);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -738,6 +995,12 @@ void Core::EmitPlayerSpectate(int32_t player_id, int32_t target_player_id)
(*_player.mOnSpectate.first)(_target.mObj);
(*mOnPlayerSpectate.first)(_player.mObj, _target.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerSpectate")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerSpectate"), _player.mLgObj, _target.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -755,10 +1018,16 @@ void Core::EmitPlayerCrashReport(int32_t player_id, const char * report)
{
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::PlayerCrashreport(%d, %s)", player_id, report)
PlayerInst & _player = m_Players.at(static_cast< size_t >(player_id));
LightObj rep(report, -1);
(*_player.mOnCrashReport.first)(rep);
(*mOnPlayerCrashReport.first)(_player.mObj, rep);
LightObj report_obj(report, -1);
(*_player.mOnCrashReport.first)(report_obj);
(*mOnPlayerCrashReport.first)(_player.mObj, report_obj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerCrashreport")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerCrashDump"), _player.mLgObj, report_obj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -766,10 +1035,16 @@ void Core::EmitPlayerModuleList(int32_t player_id, const char * list)
{
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::PlayerModuleList(%d, %s)", player_id, list)
PlayerInst & _player = m_Players.at(static_cast< size_t >(player_id));
LightObj rep(list, -1);
(*_player.mOnModuleList.first)(rep);
(*mOnPlayerModuleList.first)(_player.mObj, rep);
LightObj list_obj(list, -1);
(*_player.mOnModuleList.first)(list_obj);
(*mOnPlayerModuleList.first)(_player.mObj, list_obj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerModuleList")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerModuleList"), _player.mLgObj, list_obj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -780,6 +1055,12 @@ void Core::EmitVehicleExplode(int32_t vehicle_id)
(*_vehicle.mOnExplode.first)();
(*mOnVehicleExplode.first)(_vehicle.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::VehicleExplode")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onVehicleExplode"), _vehicle.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -790,6 +1071,12 @@ void Core::EmitVehicleRespawn(int32_t vehicle_id)
(*_vehicle.mOnRespawn.first)();
(*mOnVehicleRespawn.first)(_vehicle.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::VehicleRespawn")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onVehicleRespawn"), _vehicle.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -802,6 +1089,12 @@ void Core::EmitObjectShot(int32_t object_id, int32_t player_id, int32_t weapon_i
(*_player.mOnObjectShot.first)(_object.mObj, weapon_id);
(*mOnObjectShot.first)(_player.mObj, _object.mObj, weapon_id);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ObjectShot")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onObjectShot"), _object.mLgObj, _player.mLgObj, weapon_id);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -814,6 +1107,12 @@ void Core::EmitObjectTouched(int32_t object_id, int32_t player_id)
(*_player.mOnObjectTouched.first)(_object.mObj);
(*mOnObjectTouched.first)(_player.mObj, _object.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ObjectTouched")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onObjectBump"), _object.mLgObj, _player.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -826,6 +1125,13 @@ void Core::EmitPickupClaimed(int32_t pickup_id, int32_t player_id)
(*_player.mOnPickupClaimed.first)(_pickup.mObj);
(*mOnPickupClaimed.first)(_player.mObj, _pickup.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PickupClaimed")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
LightObj r = EvaluateLegacyEvent(m_VM, _SC("onPickupClaimPicked"), _player.mLgObj, _pickup.mLgObj);
SetState(r.IsNull() ? 1 : r.Cast< int32_t >());
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -838,6 +1144,12 @@ void Core::EmitPickupCollected(int32_t pickup_id, int32_t player_id)
(*_player.mOnPickupCollected.first)(_pickup.mObj);
(*mOnPickupCollected.first)(_player.mObj, _pickup.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PickupCollected")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPickupPickedUp"), _player.mLgObj, _pickup.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -848,6 +1160,12 @@ void Core::EmitPickupRespawn(int32_t pickup_id)
(*_pickup.mOnRespawn.first)();
(*mOnPickupRespawn.first)(_pickup.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PickupRespawn")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPickupRespawn"), _pickup.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -860,6 +1178,12 @@ void Core::EmitCheckpointEntered(int32_t checkpoint_id, int32_t player_id)
(*_player.mOnCheckpointEntered.first)(_checkpoint.mObj);
(*mOnCheckpointEntered.first)(_player.mObj, _checkpoint.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::CheckpointEntered")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onCheckpointEntered"), _player.mLgObj, _checkpoint.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -872,6 +1196,12 @@ void Core::EmitCheckpointExited(int32_t checkpoint_id, int32_t player_id)
(*_player.mOnCheckpointExited.first)(_checkpoint.mObj);
(*mOnCheckpointExited.first)(_player.mObj, _checkpoint.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::CheckpointExited")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onCheckpointExited"), _player.mLgObj, _checkpoint.mLgObj);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -983,6 +1313,12 @@ void Core::EmitPlayerHealth(int32_t player_id, float old_health, float new_healt
(*_player.mOnHealth.first)(old_health, new_health);
(*mOnPlayerHealth.first)(_player.mObj, old_health, new_health);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerHealth")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerHealthChange"), _player.mLgObj, old_health, new_health);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -993,6 +1329,12 @@ void Core::EmitPlayerArmour(int32_t player_id, float old_armour, float new_armou
(*_player.mOnArmour.first)(old_armour, new_armour);
(*mOnPlayerArmour.first)(_player.mObj, old_armour, new_armour);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerArmour")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerArmourChange"), _player.mLgObj, old_armour, new_armour);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -1003,6 +1345,12 @@ void Core::EmitPlayerWeapon(int32_t player_id, int32_t old_weapon, int32_t new_w
(*_player.mOnWeapon.first)(old_weapon, new_weapon);
(*mOnPlayerWeapon.first)(_player.mObj, old_weapon, new_weapon);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerWeapon")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onPlayerWeaponChange"), _player.mLgObj, old_weapon, new_weapon);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -1023,6 +1371,16 @@ void Core::EmitPlayerPosition(int32_t player_id)
(*_player.mOnPosition.first)(_player.mTrackPositionHeader, _player.mTrackPositionPayload);
(*mOnPlayerPosition.first)(_player.mObj, _player.mTrackPositionHeader, _player.mTrackPositionPayload);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::PlayerPosition")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
Vector3 pos;
_Func->GetPlayerPosition(player_id, &pos.x, &pos.y, &pos.z);
ExecuteLegacyEvent(m_VM, _SC("onPlayerMove"), _player.mLgObj
, _player.mLastPosition.x, _player.mLastPosition.y, _player.mLastPosition.z
, pos.x, pos.y, pos.z);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -1164,6 +1522,12 @@ void Core::EmitVehicleHealth(int32_t vehicle_id, float old_health, float new_hea
(*_vehicle.mOnHealth.first)(old_health, new_health);
(*mOnVehicleHealth.first)(_vehicle.mObj, old_health, new_health);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::VehicleHealth")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onVehicleHealthChange"), _vehicle.mLgObj, old_health, new_health);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -1174,6 +1538,16 @@ void Core::EmitVehiclePosition(int32_t vehicle_id)
(*_vehicle.mOnPosition.first)();
(*mOnVehiclePosition.first)(_vehicle.mObj);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::VehiclePosition")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
Vector3 pos;
_Func->GetVehiclePosition(vehicle_id, &pos.x, &pos.y, &pos.z);
ExecuteLegacyEvent(m_VM, _SC("onVehicleMove"), _vehicle.mLgObj
, _vehicle.mLastPosition.x, _vehicle.mLastPosition.y, _vehicle.mLastPosition.z
, pos.x, pos.y, pos.z);
}
#endif
}
// ------------------------------------------------------------------------------------------------
@ -1875,6 +2249,12 @@ void Core::EmitClientScriptData(int32_t player_id, const uint8_t * data, size_t
(*_player.mOnClientScriptData.first)(o, size);
(*mOnClientScriptData.first)(_player.mObj, o, size);
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ClientScriptData")
#ifdef VCMP_ENABLE_OFFICIAL
if (IsOfficial())
{
ExecuteLegacyEvent(m_VM, _SC("onClientScriptData"), _player.mLgObj);
}
#endif
}
#undef NULL_SQOBJ_ // don't need this anymore

4
module/Main.cpp
View File

@ -329,7 +329,7 @@ static void OnPlayerDeath(int32_t player_id, int32_t killer_id, int32_t reason,
}
else
{
Core::Get().EmitPlayerWasted(player_id, reason);
Core::Get().EmitPlayerWasted(player_id, reason, body_part);
}
SQMOD_SV_EV_TRACEBACK("[TRACE>] OnPlayerDeath")
}
@ -605,7 +605,7 @@ static void OnPlayerAwayChange(int32_t player_id, uint8_t is_away)
try
{
SQMOD_SV_EV_TRACEBACK("[TRACE<] OnPlayerAwayChange")
Core::Get().EmitPlayerAway(player_id, is_away);
Core::Get().EmitPlayerAway(player_id, is_away >= 1);
SQMOD_SV_EV_TRACEBACK("[TRACE>] OnPlayerAwayChange")
}
SQMOD_CATCH_EVENT_EXCEPTION(OnPlayerAwayChange)

1222
module/Misc/Official.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

447
module/Misc/Official.hpp Normal file
View File

@ -0,0 +1,447 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Base/Color3.hpp"
#include "Base/Color4.hpp"
#include "Base/Vector3.hpp"
#include "Base/Quaternion.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* Class used to represent a transparent ARGB color.
*/
struct LgARGB
{
/* --------------------------------------------------------------------------------------------
* The type of value used by components of type.
*/
typedef unsigned char Value;
/* --------------------------------------------------------------------------------------------
* The alpha, red, green and blue components of this type.
*/
Value a{0}, r{0}, g{0}, b{0};
/* --------------------------------------------------------------------------------------------
* Construct with individually specified alpha, red, green and blue colors.
*/
LgARGB(Value av, Value rv, Value gv, Value bv) noexcept
: a(av), r(rv), g(gv), b(bv)
{
}
};
/* ------------------------------------------------------------------------------------------------
* Entity vector.
*/
struct LgVector : public Vector3
{
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
LgVector(const Vector3 & v)
: Vector3(v)
{
}
/* --------------------------------------------------------------------------------------------
* Import from base class.
*/
using Vector3::Vector3;
using Vector3::operator =;
};
/* ------------------------------------------------------------------------------------------------
* Entity vector.
*/
struct LgEntityVector : public LgVector
{
/* --------------------------------------------------------------------------------------------
* Entity identifier.
*/
int16_t mID;
/* --------------------------------------------------------------------------------------------
* Entity type.
*/
uint8_t mType;
/* --------------------------------------------------------------------------------------------
* Vector flag.
*/
uint8_t mFlag;
/* --------------------------------------------------------------------------------------------
* Base constructor.
*/
LgEntityVector(int id, int type, int flag, Value x, Value y, Value z)
: LgVector(x, y, z)
, mID(static_cast< int16_t >(id))
, mType(static_cast< uint8_t >(type))
, mFlag(static_cast< uint8_t >(flag))
{
}
/* --------------------------------------------------------------------------------------------
* Base constructor.
*/
LgEntityVector(int id, int type, int flag, const Vector3 & v)
: LgVector(v)
, mID(static_cast< int16_t >(id))
, mType(static_cast< uint8_t >(type))
, mFlag(static_cast< uint8_t >(flag))
{
}
/* --------------------------------------------------------------------------------------------
* Retrieve the X component of the vector.
*/
SQMOD_NODISCARD Value GetX() const { return LgVector::x; }
/* --------------------------------------------------------------------------------------------
* Retrieve the Y component of the vector.
*/
SQMOD_NODISCARD Value GetY() const { return LgVector::y; }
/* --------------------------------------------------------------------------------------------
* Retrieve the Z component of the vector.
*/
SQMOD_NODISCARD Value GetZ() const { return LgVector::z; }
/* --------------------------------------------------------------------------------------------
* Modify the X component of the vector.
*/
void SetX(Value v) { LgVector::x = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the Y component of the vector.
*/
void SetY(Value v) { LgVector::y = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the Z component of the vector.
*/
void SetZ(Value v) { LgVector::z = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the X, Y and Z component of the vector.
*/
void Set();
/* --------------------------------------------------------------------------------------------
* Import from base class.
*/
using LgVector::LgVector;
using LgVector::operator =;
};
/* ------------------------------------------------------------------------------------------------
* Entity quaternion.
*/
struct LgQuaternion : public Quaternion
{
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
LgQuaternion(const Quaternion & q)
: Quaternion(q)
{
}
/* --------------------------------------------------------------------------------------------
* Import from base class.
*/
using Quaternion::Quaternion;
using Quaternion::operator =;
};
/* ------------------------------------------------------------------------------------------------
* Entity quaternion.
*/
struct LgEntityQuaternion : public LgQuaternion
{
/* --------------------------------------------------------------------------------------------
* Entity identifier.
*/
int16_t mID;
/* --------------------------------------------------------------------------------------------
* Entity type.
*/
uint8_t mType;
/* --------------------------------------------------------------------------------------------
* Quaternion flag.
*/
uint8_t mFlag;
/* --------------------------------------------------------------------------------------------
* Base constructor.
*/
LgEntityQuaternion(int id, int type, int flag, Value x, Value y, Value z, Value w)
: LgQuaternion(x, y, z, w)
, mID(static_cast< int16_t >(id))
, mType(static_cast< uint8_t >(type))
, mFlag(static_cast< uint8_t >(flag))
{
}
/* --------------------------------------------------------------------------------------------
* Base constructor.
*/
LgEntityQuaternion(int id, int type, int flag, const Quaternion & q)
: LgQuaternion(q)
, mID(static_cast< int16_t >(id))
, mType(static_cast< uint8_t >(type))
, mFlag(static_cast< uint8_t >(flag))
{
}
/* --------------------------------------------------------------------------------------------
* Retrieve the X component of the quaternion.
*/
SQMOD_NODISCARD Value GetX() const { return LgQuaternion::x; }
/* --------------------------------------------------------------------------------------------
* Retrieve the Y component of the quaternion.
*/
SQMOD_NODISCARD Value GetY() const { return LgQuaternion::y; }
/* --------------------------------------------------------------------------------------------
* Retrieve the Z component of the quaternion.
*/
SQMOD_NODISCARD Value GetZ() const { return LgQuaternion::z; }
/* --------------------------------------------------------------------------------------------
* Retrieve the W component of the quaternion.
*/
SQMOD_NODISCARD Value GetW() const { return LgQuaternion::w; }
/* --------------------------------------------------------------------------------------------
* Modify the X component of the quaternion.
*/
void SetX(Value v) { LgQuaternion::x = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the Y component of the quaternion.
*/
void SetY(Value v) { LgQuaternion::y = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the Z component of the quaternion.
*/
void SetZ(Value v) { LgQuaternion::z = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the W component of the quaternion.
*/
void SetW(Value v) { LgQuaternion::w = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the X, Y, Z and W component of the quaternion.
*/
void Set();
/* --------------------------------------------------------------------------------------------
* Import from base class.
*/
using LgQuaternion::LgQuaternion;
using LgQuaternion::operator =;
};
/* ------------------------------------------------------------------------------------------------
* Class used to represent a transparent RGB color.
*/
struct LgRGB : public Color3
{
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
LgRGB(const Color3 & c)
: Color3(c)
{
}
/* --------------------------------------------------------------------------------------------
* Import from base class.
*/
using Color3::Color3;
using Color3::operator =;
};
/* ------------------------------------------------------------------------------------------------
* Class used to represent a transparent RGBA color.
*/
struct LgRGBA : public Color4
{
/* --------------------------------------------------------------------------------------------
* Import from base class.
*/
using Color4::Color4;
using Color4::operator =;
};
/* ------------------------------------------------------------------------------------------------
* Entity color.
*/
struct LgEntityRGB : public LgRGB
{
/* --------------------------------------------------------------------------------------------
* Entity identifier.
*/
int16_t mID;
/* --------------------------------------------------------------------------------------------
* Entity type.
*/
uint8_t mType;
/* --------------------------------------------------------------------------------------------
* Color flag.
*/
uint8_t mFlag;
/* --------------------------------------------------------------------------------------------
* Base constructor.
*/
LgEntityRGB(int id, int type, int flag, Value r, Value g, Value b)
: LgRGB(r, g, b)
, mID(static_cast< int16_t >(id))
, mType(static_cast< uint8_t >(type))
, mFlag(static_cast< uint8_t >(flag))
{
}
/* --------------------------------------------------------------------------------------------
* Base constructor.
*/
LgEntityRGB(int id, int type, int flag, const Color3 & c)
: LgRGB(c)
, mID(static_cast< int16_t >(id))
, mType(static_cast< uint8_t >(type))
, mFlag(static_cast< uint8_t >(flag))
{
}
/* --------------------------------------------------------------------------------------------
* Retrieve the Red component of the color.
*/
SQMOD_NODISCARD Value GetR() const { return LgRGB::r; }
/* --------------------------------------------------------------------------------------------
* Retrieve the Green component of the color.
*/
SQMOD_NODISCARD Value GetG() const { return LgRGB::g; }
/* --------------------------------------------------------------------------------------------
* Retrieve the Blue component of the color.
*/
SQMOD_NODISCARD Value GetB() const { return LgRGB::b; }
/* --------------------------------------------------------------------------------------------
* Modify the Red component of the color.
*/
void SetR(Value v) { LgRGB::r = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the Green component of the color.
*/
void SetG(Value v) { LgRGB::g = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the Blue component of the color.
*/
void SetB(Value v) { LgRGB::b = v; Set(); }
/* --------------------------------------------------------------------------------------------
* Modify the red, Green and Blue component of the color.
*/
void Set();
/* --------------------------------------------------------------------------------------------
* Import from base class.
*/
using LgRGB::LgRGB;
using LgRGB::operator =;
};
/* ------------------------------------------------------------------------------------------------
* Class used to represent 2D area boundaries.
*/
struct LgBounds
{
/* --------------------------------------------------------------------------------------------
* The type of value used by components of type.
*/
typedef unsigned char Value;
/* --------------------------------------------------------------------------------------------
* Upper and lower bounds of the area.
*/
Value max_x;
Value min_x;
Value max_y;
Value min_y;
/* --------------------------------------------------------------------------------------------
* Construct with default (empty/zero) bounds.
*/
LgBounds()
: max_x(0), min_x(0), max_y(0), min_y(0)
{
}
/* --------------------------------------------------------------------------------------------
* Construct with individually specified bounds.
*/
LgBounds(Value xmax, Value xmin, Value ymax, Value ymin)
: max_x(xmax), min_x(xmin), max_y(ymax), min_y(ymin)
{
}
};
/* ------------------------------------------------------------------------------------------------
* Class used to represent wasted settings.
*/
struct LgWastedSettings
{
/* --------------------------------------------------------------------------------------------
* Settings values.
*/
uint32_t mDeathTime;
uint32_t mFadeTime;
float mFadeInSpeed;
float mFadeOutSpeed;
LgRGB mFadeColour;
uint32_t mCorpseFadeDelay;
uint32_t mCorpseFadeTime;
/* --------------------------------------------------------------------------------------------
* Construct with default settings.
*/
LgWastedSettings()
: mDeathTime(0)
, mFadeTime(0)
, mFadeInSpeed(0.0f)
, mFadeOutSpeed(0.0f)
, mFadeColour(0)
, mCorpseFadeDelay(0)
, mCorpseFadeTime(0)
{
}
/* --------------------------------------------------------------------------------------------
* Construct with individually specified settings.
*/
LgWastedSettings(uint32_t death_time, uint32_t fade_time, float fade_in_speed, float fade_out_speed,
LgRGB fade_colour, uint32_t corpse_fade_delay, uint32_t corpse_fade_time)
: mDeathTime(death_time)
, mFadeTime(fade_time)
, mFadeInSpeed(fade_in_speed)
, mFadeOutSpeed(fade_out_speed)
, mFadeColour(fade_colour)
, mCorpseFadeDelay(corpse_fade_delay)
, mCorpseFadeTime(corpse_fade_time)
{
}
};
} // Namespace:: SqMod

6
module/Register.cpp
View File

@ -56,6 +56,9 @@ extern void Register_Tasks(HSQUIRRELVM vm);
extern void Register_Misc(HSQUIRRELVM vm);
extern void Register_Areas(HSQUIRRELVM vm);
extern void Register_Signal(HSQUIRRELVM vm);
#ifdef VCMP_ENABLE_OFFICIAL
extern void Register_Official(HSQUIRRELVM vm);
#endif
// ------------------------------------------------------------------------------------------------
bool RegisterAPI(HSQUIRRELVM vm)
@ -103,6 +106,9 @@ bool RegisterAPI(HSQUIRRELVM vm)
Register_Misc(vm);
Register_Areas(vm);
Register_Signal(vm);
#ifdef VCMP_ENABLE_OFFICIAL
Register_Official(vm);
#endif
return true;
}

15
module/SqBase.hpp
View File

@ -88,6 +88,21 @@
#define SQMOD_SDK_LEAST(MJR, MNR) ((PLUGIN_API_MAJOR >= (MJR)) && (PLUGIN_API_MINOR >= (MNR)))
#define SQMOD_SDK_PRIOR(MJR, MNR) ((PLUGIN_API_MAJOR < (MJR)) && (PLUGIN_API_MINOR < (MNR)))
/* ------------------------------------------------------------------------------------------------
* VCMP OFFICIAL SUPPORT.
*/
#ifdef VCMP_ENABLE_OFFICIAL
#define SQMOD_OFFICIAL_ONLY(EXPR) EXPR
#define SQMOD_EXCEPT_OFFICIAL(EXPR)
#else
#define SQMOD_OFFICIAL_ONLY(EXPR)
#define SQMOD_EXCEPT_OFFICIAL(EXPR) EXPR
#endif
// --------------------------------------------------------------------------------------------------------------------
// Select the value according to the selected option.
#define SQMOD_OFFICIAL_OR(XV, OV) SQMOD_OFFICIAL_ONLY(XV) SQMOD_EXCEPT_OFFICIAL(OV)
#define SQMOD_NON_OFFICIAL_OR(XV, OV) SQMOD_EXCEPT_OFFICIAL(XV) SQMOD_OFFICIAL_ONLY(OV)
/* ------------------------------------------------------------------------------------------------
* API EXPORT.
*/