#ifndef _CORE_HPP_
#define _CORE_HPP_
// ------------------------------------------------------------------------------------------------
#include "Base/Shared.hpp"
#include "Base/Vector3.hpp"
#include "Base/Quaternion.hpp"
#include "Base/Color4.hpp"
#include "Base/ScriptSrc.hpp"
// ------------------------------------------------------------------------------------------------
#include <vector>
#include <unordered_map>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* Circular locks employed by the central core.
*/
enum CoreCircularLocks
{
CCL_RELOAD_SCRIPTS = (1 << 0),
CCL_EMIT_SERVER_OPTION = (1 << 1)
};
/* ------------------------------------------------------------------------------------------------
* Core module class responsible for managing resources.
*/
class Core
{
private:
// --------------------------------------------------------------------------------------------
static Core s_Inst; // Core instance.
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
Core();
/* --------------------------------------------------------------------------------------------
* Copy constructor. (disabled)
*/
Core(const Core & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor. (disabled)
*/
Core(Core && o) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~Core();
/* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled)
*/
Core & operator = (const Core & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator. (disabled)
*/
Core & operator = (Core && o) = delete;
protected:
// --------------------------------------------------------------------------------------------
typedef std::vector< std::pair< Area *, LightObj > > AreaList; // List of colided areas.
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify a blip entity instance on the server.
*/
struct BlipInst
{
/* ----------------------------------------------------------------------------------------
* Default constructor.
*/
BlipInst() : mID(-1), mFlags(ENF_DEFAULT), mInst(nullptr), mObj()
{
ResetInstance();
}
/* ----------------------------------------------------------------------------------------
* Destructor.
*/
~BlipInst()
{
if (VALID_ENTITY(mID))
{
Destroy(!Core::Get().ShuttingDown(), SQMOD_DESTROY_CLEANUP, NullLightObj());
}
}
/* ----------------------------------------------------------------------------------------
* Destroy the entity instance from the server, if necessary.
*/
void Destroy(bool destroy, Int32 header, LightObj & payload);
/* ----------------------------------------------------------------------------------------
* Reset the instance to the default values.
*/
void ResetInstance();
/* ----------------------------------------------------------------------------------------
* Create the associated signals.
*/
void InitEvents();
/* ----------------------------------------------------------------------------------------
* Clear the associated signals.
*/
void DropEvents();
// ----------------------------------------------------------------------------------------
Int32 mID; // The unique number that identifies this entity on the server.
Uint32 mFlags; // Various options and states that can be toggled on the instance.
CBlip * mInst; // Pointer to the actual instance used to interact this entity.
LightObj mObj; // Script object of the instance used to interact this entity.
// ----------------------------------------------------------------------------------------
Int32 mWorld; // The identifier of the world in which this blip was created.
Int32 mScale; // The scale of the blip.
// ----------------------------------------------------------------------------------------
Int32 mSprID;
// ----------------------------------------------------------------------------------------
LightObj mEvents; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
Vector3 mPosition;
Color4 mColor;
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed;
SignalPair mOnCustom;
};
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify a checkpoint entity instance on the server.
*/
struct CheckpointInst
{
/* ----------------------------------------------------------------------------------------
* Default constructor.
*/
CheckpointInst() : mID(-1), mFlags(ENF_DEFAULT), mInst(nullptr), mObj()
{
ResetInstance();
}
/* ----------------------------------------------------------------------------------------
* Destructor.
*/
~CheckpointInst()
{
if (VALID_ENTITY(mID))
{
Destroy(!Core::Get().ShuttingDown(), SQMOD_DESTROY_CLEANUP, NullLightObj());
}
}
/* ----------------------------------------------------------------------------------------
* Destroy the entity instance from the server, if necessary.
*/
void Destroy(bool destroy, Int32 header, LightObj & payload);
/* ----------------------------------------------------------------------------------------
* Reset the instance to the default values.
*/
void ResetInstance();
/* ----------------------------------------------------------------------------------------
* Create the associated signals.
*/
void InitEvents();
/* ----------------------------------------------------------------------------------------
* Clear the associated signals.
*/
void DropEvents();
// ----------------------------------------------------------------------------------------
Int32 mID; // The unique number that identifies this entity on the server.
Uint32 mFlags; // Various options and states that can be toggled on the instance.
CCheckpoint * mInst; // Pointer to the actual instance used to interact this entity.
LightObj mObj; // Script object of the instance used to interact this entity.
// ----------------------------------------------------------------------------------------
LightObj mEvents; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed;
SignalPair mOnCustom;
SignalPair mOnStream;
// ----------------------------------------------------------------------------------------
SignalPair mOnEntered;
SignalPair mOnExited;
SignalPair mOnWorld;
SignalPair mOnRadius;
};
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify a key-bind entity instance on the server.
*/
struct KeybindInst
{
/* ----------------------------------------------------------------------------------------
* Default constructor.
*/
KeybindInst() : mID(-1), mFlags(ENF_DEFAULT), mInst(nullptr), mObj()
{
ResetInstance();
}
/* ----------------------------------------------------------------------------------------
* Destructor.
*/
~KeybindInst()
{
if (VALID_ENTITY(mID))
{
Destroy(!Core::Get().ShuttingDown(), SQMOD_DESTROY_CLEANUP, NullLightObj());
}
}
/* ----------------------------------------------------------------------------------------
* Destroy the entity instance from the server, if necessary.
*/
void Destroy(bool destroy, Int32 header, LightObj & payload);
/* ----------------------------------------------------------------------------------------
* Reset the instance to the default values.
*/
void ResetInstance();
/* ----------------------------------------------------------------------------------------
* Create the associated signals.
*/
void InitEvents();
/* ----------------------------------------------------------------------------------------
* Clear the associated signals.
*/
void DropEvents();
// ----------------------------------------------------------------------------------------
Int32 mID; // The unique number that identifies this entity on the server.
Uint32 mFlags; // Various options and states that can be toggled on the instance.
CKeybind * mInst; // Pointer to the actual instance used to interact this entity.
LightObj mObj; // Script object of the instance used to interact this entity.
// ----------------------------------------------------------------------------------------
Int32 mFirst; // Key-code of the first button from the triggering combination.
Int32 mSecond; // Key-code of the second button from the triggering combination.
Int32 mThird; // Key-code of the third button from the triggering combination.
Int32 mRelease; // Whether the key-bind reacts to button press or release.
// ----------------------------------------------------------------------------------------
LightObj mEvents; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed;
SignalPair mOnCustom;
// ----------------------------------------------------------------------------------------
SignalPair mOnKeyPress;
SignalPair mOnKeyRelease;
};
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify an object entity instance on the server.
*/
struct ObjectInst
{
/* ----------------------------------------------------------------------------------------
* Default constructor.
*/
ObjectInst() : mID(-1), mFlags(ENF_DEFAULT), mInst(nullptr), mObj()
{
ResetInstance();
}
/* ----------------------------------------------------------------------------------------
* Destructor.
*/
~ObjectInst()
{
if (VALID_ENTITY(mID))
{
Destroy(!Core::Get().ShuttingDown(), SQMOD_DESTROY_CLEANUP, NullLightObj());
}
}
/* ----------------------------------------------------------------------------------------
* Destroy the entity instance from the server, if necessary.
*/
void Destroy(bool destroy, Int32 header, LightObj & payload);
/* ----------------------------------------------------------------------------------------
* Reset the instance to the default values.
*/
void ResetInstance();
/* ----------------------------------------------------------------------------------------
* Create the associated signals.
*/
void InitEvents();
/* ----------------------------------------------------------------------------------------
* Clear the associated signals.
*/
void DropEvents();
// ----------------------------------------------------------------------------------------
Int32 mID; // The unique number that identifies this entity on the server.
Uint32 mFlags; // Various options and states that can be toggled on the instance.
CObject * mInst; // Pointer to the actual instance used to interact this entity.
LightObj mObj; // Script object of the instance used to interact this entity.
// ----------------------------------------------------------------------------------------
LightObj mEvents; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed;
SignalPair mOnCustom;
SignalPair mOnStream;
// ----------------------------------------------------------------------------------------
SignalPair mOnShot;
SignalPair mOnTouched;
SignalPair mOnWorld;
SignalPair mOnAlpha;
SignalPair mOnReport;
};
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify a pickup entity instance on the server.
*/
struct PickupInst
{
/* ----------------------------------------------------------------------------------------
* Default constructor.
*/
PickupInst() : mID(-1), mFlags(ENF_DEFAULT), mInst(nullptr), mObj()
{
ResetInstance();
}
/* ----------------------------------------------------------------------------------------
* Destructor.
*/
~PickupInst()
{
if (VALID_ENTITY(mID))
{
Destroy(!Core::Get().ShuttingDown(), SQMOD_DESTROY_CLEANUP, NullLightObj());
}
}
/* ----------------------------------------------------------------------------------------
* Destroy the entity instance from the server, if necessary.
*/
void Destroy(bool destroy, Int32 header, LightObj & payload);
/* ----------------------------------------------------------------------------------------
* Reset the instance to the default values.
*/
void ResetInstance();
/* ----------------------------------------------------------------------------------------
* Create the associated signals.
*/
void InitEvents();
/* ----------------------------------------------------------------------------------------
* Clear the associated signals.
*/
void DropEvents();
// ----------------------------------------------------------------------------------------
Int32 mID; // The unique number that identifies this entity on the server.
Uint32 mFlags; // Various options and states that can be toggled on the instance.
CPickup * mInst; // Pointer to the actual instance used to interact this entity.
LightObj mObj; // Script object of the instance used to interact this entity.
// ----------------------------------------------------------------------------------------
LightObj mEvents; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed;
SignalPair mOnCustom;
SignalPair mOnStream;
// ----------------------------------------------------------------------------------------
SignalPair mOnRespawn;
SignalPair mOnClaimed;
SignalPair mOnCollected;
SignalPair mOnWorld;
SignalPair mOnAlpha;
SignalPair mOnAutomatic;
SignalPair mOnAutoTimer;
SignalPair mOnOption;
};
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify a player entity instance on the server.
*/
struct PlayerInst
{
/* ----------------------------------------------------------------------------------------
* Default constructor.
*/
PlayerInst() : mID(-1), mFlags(ENF_DEFAULT), mInst(nullptr), mObj()
{
ResetInstance();
}
/* ----------------------------------------------------------------------------------------
* Destructor.
*/
~PlayerInst()
{
if (VALID_ENTITY(mID))
{
Destroy(false, SQMOD_DESTROY_CLEANUP, NullLightObj());
}
}
/* ----------------------------------------------------------------------------------------
* Destroy the entity instance from the server, if necessary.
*/
void Destroy(bool destroy, Int32 header, LightObj & payload);
/* ----------------------------------------------------------------------------------------
* Reset the instance to the default values.
*/
void ResetInstance();
/* ----------------------------------------------------------------------------------------
* Create the associated signals.
*/
void InitEvents();
/* ----------------------------------------------------------------------------------------
* Clear the associated signals.
*/
void DropEvents();
// ----------------------------------------------------------------------------------------
Int32 mID; // The unique number that identifies this entity on the server.
Uint32 mFlags; // Various options and states that can be toggled on the instance.
CPlayer * mInst; // Pointer to the actual instance used to interact this entity.
LightObj mObj; // Script object of the instance used to interact this entity.
// ----------------------------------------------------------------------------------------
AreaList mAreas; // Areas the player is currently in.
// ----------------------------------------------------------------------------------------
SQInteger mTrackPosition; // The number of times to track position changes.
SQInteger mTrackHeading; // The number of times to track heading changes.
// ----------------------------------------------------------------------------------------
Int32 mTrackPositionHeader; // Header to send when triggering position callback.
LightObj mTrackPositionPayload; // Payload to send when triggering position callback.
// ----------------------------------------------------------------------------------------
Int32 mKickBanHeader; // Header to send when triggering kick/ban callback.
LightObj mKickBanPayload; // Payload to send when triggering kick/ban callback.
// ----------------------------------------------------------------------------------------
Int32 mLastWeapon; // Last known weapon of the player entity.
Float32 mLastHealth; // Last known health of the player entity.
Float32 mLastArmour; // Last known armor of the player entity.
Float32 mLastHeading; // Last known heading of the player entity.
Vector3 mLastPosition; // Last known position of the player entity.
// ----------------------------------------------------------------------------------------
Int32 mAuthority; // The authority level of the managed player.
// ----------------------------------------------------------------------------------------
LightObj mEvents; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed;
SignalPair mOnCustom;
SignalPair mOnStream;
// ----------------------------------------------------------------------------------------
SignalPair mOnRequestClass;
SignalPair mOnRequestSpawn;
SignalPair mOnSpawn;
SignalPair mOnWasted;
SignalPair mOnKilled;
SignalPair mOnEmbarking;
SignalPair mOnEmbarked;
SignalPair mOnDisembark;
SignalPair mOnRename;
SignalPair mOnState;
SignalPair mOnStateNone;
SignalPair mOnStateNormal;
SignalPair mOnStateAim;
SignalPair mOnStateDriver;
SignalPair mOnStatePassenger;
SignalPair mOnStateEnterDriver;
SignalPair mOnStateEnterPassenger;
SignalPair mOnStateExit;
SignalPair mOnStateUnspawned;
SignalPair mOnAction;
SignalPair mOnActionNone;
SignalPair mOnActionNormal;
SignalPair mOnActionAiming;
SignalPair mOnActionShooting;
SignalPair mOnActionJumping;
SignalPair mOnActionLieDown;
SignalPair mOnActionGettingUp;
SignalPair mOnActionJumpVehicle;
SignalPair mOnActionDriving;
SignalPair mOnActionDying;
SignalPair mOnActionWasted;
SignalPair mOnActionEmbarking;
SignalPair mOnActionDisembarking;
SignalPair mOnBurning;
SignalPair mOnCrouching;
SignalPair mOnGameKeys;
SignalPair mOnStartTyping;
SignalPair mOnStopTyping;
SignalPair mOnAway;
SignalPair mOnMessage;
SignalPair mOnCommand;
SignalPair mOnPrivateMessage;
SignalPair mOnKeyPress;
SignalPair mOnKeyRelease;
SignalPair mOnSpectate;
SignalPair mOnUnspectate;
SignalPair mOnCrashreport;
SignalPair mOnModuleList;
SignalPair mOnObjectShot;
SignalPair mOnObjectTouched;
SignalPair mOnPickupClaimed;
SignalPair mOnPickupCollected;
SignalPair mOnCheckpointEntered;
SignalPair mOnCheckpointExited;
SignalPair mOnClientScriptData;
SignalPair mOnEntityStream;
SignalPair mOnUpdate;
SignalPair mOnHealth;
SignalPair mOnArmour;
SignalPair mOnWeapon;
SignalPair mOnHeading;
SignalPair mOnPosition;
SignalPair mOnOption;
SignalPair mOnAdmin;
SignalPair mOnWorld;
SignalPair mOnTeam;
SignalPair mOnSkin;
SignalPair mOnMoney;
SignalPair mOnScore;
SignalPair mOnWantedLevel;
SignalPair mOnImmunity;
SignalPair mOnAlpha;
SignalPair mOnEnterArea;
SignalPair mOnLeaveArea;
};
/* --------------------------------------------------------------------------------------------
* Helper structure used to identify a vehicle entity instance on the server.
*/
struct VehicleInst
{
/* ----------------------------------------------------------------------------------------
* Default constructor.
*/
VehicleInst() : mID(-1), mFlags(ENF_DEFAULT), mInst(nullptr), mObj()
{
ResetInstance();
}
/* ----------------------------------------------------------------------------------------
* Destructor.
*/
~VehicleInst()
{
if (VALID_ENTITY(mID))
{
Destroy(!Core::Get().ShuttingDown(), SQMOD_DESTROY_CLEANUP, NullLightObj());
}
}
/* ----------------------------------------------------------------------------------------
* Destroy the entity instance from the server, if necessary.
*/
void Destroy(bool destroy, Int32 header, LightObj & payload);
/* ----------------------------------------------------------------------------------------
* Reset the instance to the default values.
*/
void ResetInstance();
/* ----------------------------------------------------------------------------------------
* Create the associated signals.
*/
void InitEvents();
/* ----------------------------------------------------------------------------------------
* Clear the associated signals.
*/
void DropEvents();
// ----------------------------------------------------------------------------------------
Int32 mID; // The unique number that identifies this entity on the server.
Uint32 mFlags; // Various options and states that can be toggled on the instance.
CVehicle * mInst; // Pointer to the actual instance used to interact this entity.
LightObj mObj; // Script object of the instance used to interact this entity.
// ----------------------------------------------------------------------------------------
AreaList mAreas; // Areas the vehicle is currently in.
// ----------------------------------------------------------------------------------------
SQInteger mTrackPosition; // The number of times to track position changes.
SQInteger mTrackRotation; // The number of times to track rotation changes.
// ----------------------------------------------------------------------------------------
Int32 mLastPrimaryColor; // Last known secondary-color of the player entity.
Int32 mLastSecondaryColor; // Last known primary-color of the player entity.
Float32 mLastHealth; // Last known health of the player entity.
Vector3 mLastPosition; // Last known position of the player entity.
Quaternion mLastRotation; // Last known rotation of the player entity.
// ----------------------------------------------------------------------------------------
LightObj mEvents; // Table containing the emitted entity events.
// ----------------------------------------------------------------------------------------
SignalPair mOnDestroyed;
SignalPair mOnCustom;
SignalPair mOnStream;
// ----------------------------------------------------------------------------------------
SignalPair mOnEmbarking;
SignalPair mOnEmbarked;
SignalPair mOnDisembark;
SignalPair mOnExplode;
SignalPair mOnRespawn;
SignalPair mOnUpdate;
SignalPair mOnColor;
SignalPair mOnHealth;
SignalPair mOnPosition;
SignalPair mOnRotation;
SignalPair mOnOption;
SignalPair mOnWorld;
SignalPair mOnImmunity;
SignalPair mOnPartStatus;
SignalPair mOnTyreStatus;
SignalPair mOnDamageData;
SignalPair mOnRadio;
SignalPair mOnHandlingRule;
SignalPair mOnEnterArea;
SignalPair mOnLeaveArea;
};
public:
// --------------------------------------------------------------------------------------------
typedef std::vector< BlipInst > Blips; // Blips entity instances container.
typedef std::vector< CheckpointInst > Checkpoints; // Checkpoints entity instances container.
typedef std::vector< KeybindInst > Keybinds; // Key-binds entity instances container.
typedef std::vector< ObjectInst > Objects; // Objects entity instances container.
typedef std::vector< PickupInst > Pickups; // Pickups entity instances container.
typedef std::vector< PlayerInst > Players; // Players entity instances container.
typedef std::vector< VehicleInst > Vehicles; // Vehicles entity instances container.
// --------------------------------------------------------------------------------------------
typedef std::vector< ScriptSrc > Scripts; // List of loaded scripts.
// --------------------------------------------------------------------------------------------
typedef std::unordered_map< String, String > Options; // List of custom options.
private:
// --------------------------------------------------------------------------------------------
Int32 m_State; // Current plug-in state.
HSQUIRRELVM m_VM; // Script virtual machine.
Scripts m_Scripts; // Loaded scripts objects.
Scripts m_PendingScripts; // Pending scripts objects.
Options m_Options; // Custom configuration options.
// --------------------------------------------------------------------------------------------
Blips m_Blips; // Blips pool.
Checkpoints m_Checkpoints; // Checkpoints pool.
Keybinds m_Keybinds; // Key-binds pool.
Objects m_Objects; // Objects pool.
Pickups m_Pickups; // Pickups pool.
Players m_Players; // Players pool.
Vehicles m_Vehicles; // Vehicles pool.
// --------------------------------------------------------------------------------------------
LightObj m_Events; // Table containing the emitted module events.
// --------------------------------------------------------------------------------------------
Uint32 m_CircularLocks; // Prevent events from triggering themselves.
// --------------------------------------------------------------------------------------------
Int32 m_ReloadHeader; // The specified reload header.
LightObj m_ReloadPayload; // The specified reload payload.
// --------------------------------------------------------------------------------------------
CStr m_IncomingNameBuffer; // Name of an incoming connection.
size_t m_IncomingNameCapacity; // Incoming connection name size.
// --------------------------------------------------------------------------------------------
bool m_AreasEnabled; // Whether area tracking is enabled.
bool m_Debugging; // Enable debugging features, if any.
bool m_Executed; // Whether the scripts were executed.
bool m_Shutdown; // Whether the server currently shutting down.
bool m_LockPreLoadSignal; // Lock pre load signal container.
bool m_LockPostLoadSignal; // Lock post load signal container.
bool m_LockUnloadSignal; // Lock unload signal container.
bool m_EmptyInit; // Whether to initialize without any scripts.
// --------------------------------------------------------------------------------------------
Int32 m_Verbosity; // Restrict the amount of outputted information.
// --------------------------------------------------------------------------------------------
LightObj m_NullBlip; // Null Blips instance.
LightObj m_NullCheckpoint; // Null Checkpoints instance.
LightObj m_NullKeybind; // Null Key-instance pool.
LightObj m_NullObject; // Null Objects instance.
LightObj m_NullPickup; // Null Pickups instance.
LightObj m_NullPlayer; // Null Players instance.
LightObj m_NullVehicle; // Null Vehicles instance.
public:
/* --------------------------------------------------------------------------------------------
* Retrieve the core instance.
*/
static Core & Get()
{
return s_Inst;
}
/* --------------------------------------------------------------------------------------------
* Initialize the plug-in core.
*/
bool Initialize();
/* --------------------------------------------------------------------------------------------
* Load and execute plug-in resources.
*/
bool Execute();
/* --------------------------------------------------------------------------------------------
* Terminate the plug-in core.
*/
void Terminate(bool shutdown = false);
/* --------------------------------------------------------------------------------------------
* Reload the plug-in core.
*/
bool Reload();
/* --------------------------------------------------------------------------------------------
* Modify the current plug-in state.
*/
void SetState(Int32 val)
{
m_State = val;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the current plug-in state.
*/
Int32 GetState() const
{
return m_State;
}
/* --------------------------------------------------------------------------------------------
* See whether debugging option was enabled in the plug-in.
*/
bool IsDebugging() const
{
return m_Debugging;
}
/* --------------------------------------------------------------------------------------------
* See whether all queued scripts were executed and the plug-in fully started.
*/
bool IsExecuted() const
{
return m_Executed;
}
/* --------------------------------------------------------------------------------------------
* See whether the server is currently in the process of shutting down.
*/
bool ShuttingDown() const
{
return m_Shutdown;
}
/* --------------------------------------------------------------------------------------------
* See whether area tracking should be enabled on newlly created entities.
*/
bool AreasEnabled() const
{
return m_AreasEnabled;
}
/* --------------------------------------------------------------------------------------------
* Toggle whether area tracking should be enabled on newlly created entities.
*/
void AreasEnabled(bool toggle)
{
m_AreasEnabled = toggle;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the value of the specified option.
*/
CSStr GetOption(CSStr name) const;
/* --------------------------------------------------------------------------------------------
* Retrieve the value of the specified option or the fall back value if it doesn't exist.
*/
CSStr GetOption(CSStr name, CSStr value) const;
/* --------------------------------------------------------------------------------------------
* Modify the value of the specified option.
*/
void SetOption(CSStr name, CSStr value);
/* --------------------------------------------------------------------------------------------
* Retrieve the script source associated with a certain path in the scripts list.
*/
Scripts::iterator FindScript(const CSStr src);
/* --------------------------------------------------------------------------------------------
* Retrieve the script source associated with a certain path in the pending scripts list.
*/
Scripts::iterator FindPendingScript(const CSStr src);
/* --------------------------------------------------------------------------------------------
* Retrieve the scripts list. Should not be modified directly! Information purposes only.
*/
Scripts & GetScripts()
{
return m_Scripts;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the pending scripts list. Should not be modified directly! Information purposes only.
*/
Scripts & GetPendingScripts()
{
return m_PendingScripts;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the virtual machine.
*/
HSQUIRRELVM GetVM() const
{
return m_VM;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the global events table.
*/
LightObj & GetEvents()
{
return m_Events;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the circular locks.
*/
Uint32 & GetCircularLock()
{
return m_CircularLocks;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the preload signal if not complete.
*/
LightObj & GetPreLoadEvent()
{
return m_LockPreLoadSignal ? NullLightObj() : mOnPreLoad.second;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the postload signal if not complete.
*/
LightObj & GetPostLoadEvent()
{
return m_LockPostLoadSignal ? NullLightObj() : mOnPostLoad.second;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the unload signal if not complete.
*/
LightObj & GetUnloadEvent()
{
return m_LockUnloadSignal ? NullLightObj() : mOnUnload.second;
}
/* --------------------------------------------------------------------------------------------
* See if certain circular locks are enabled.
*/
bool IsCircularLock(Uint32 lock) const
{
return (m_CircularLocks & lock);
}
/* --------------------------------------------------------------------------------------------
* Set the header and payload for the reload.
*/
void SetReloadInfo(Int32 header, LightObj & payload)
{
m_ReloadHeader = header;
m_ReloadPayload = payload;
}
/* --------------------------------------------------------------------------------------------
* Reset the header and payload for the reload.
*/
void ResetReloadInfo()
{
m_ReloadHeader = -1;
m_ReloadPayload.Release();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the specified reload header.
*/
Int32 GetReloadHeader() const
{
return m_ReloadHeader;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the specified reload header.
*/
LightObj & GetReloadPayload()
{
return m_ReloadPayload;
}
/* --------------------------------------------------------------------------------------------
* Adds a script to the load queue.
*/
bool LoadScript(CSStr filepath, bool delay);
/* --------------------------------------------------------------------------------------------
* Modify the name for the currently assigned incoming connection.
*/
void SetIncomingName(CSStr name);
/* --------------------------------------------------------------------------------------------
* Retrieve the name for the currently assigned incoming connection.
*/
CSStr GetIncomingName()
{
return (!m_IncomingNameBuffer) ? _SC("") : m_IncomingNameBuffer;
}
/* --------------------------------------------------------------------------------------------
* Retrieves a line of code from a certain source.
*/
String FetchCodeLine(CSStr src, SQInteger line, bool trim = true);
protected:
/* --------------------------------------------------------------------------------------------
* Script execution process.
*/
static bool DoScripts(Scripts::iterator itr, Scripts::iterator end);
/* --------------------------------------------------------------------------------------------
* Script output handlers.
*/
static void PrintFunc(HSQUIRRELVM vm, CSStr msg, ...);
static void ErrorFunc(HSQUIRRELVM vm, CSStr msg, ...);
/* --------------------------------------------------------------------------------------------
* Script error handlers.
*/
static SQInteger RuntimeErrorHandler(HSQUIRRELVM vm);
static void CompilerErrorHandler(HSQUIRRELVM vm, CSStr desc, CSStr src,
SQInteger line, SQInteger column);
bool CompilerErrorHandlerEx(CSStr desc, CSStr src, SQInteger line, SQInteger column);
/* --------------------------------------------------------------------------------------------
* Entity scanners.
*/
void ImportBlips();
void ImportCheckpoints();
void ImportKeybinds();
void ImportObjects();
void ImportPickups();
void ImportPlayers();
void ImportVehicles();
/* --------------------------------------------------------------------------------------------
* Entity allocators.
*/
BlipInst & AllocBlip(Int32 id, bool owned, Int32 header, LightObj & payload);
CheckpointInst & AllocCheckpoint(Int32 id, bool owned, Int32 header, LightObj & payload);
KeybindInst & AllocKeybind(Int32 id, bool owned, Int32 header, LightObj & payload);
ObjectInst & AllocObject(Int32 id, bool owned, Int32 header, LightObj & payload);
PickupInst & AllocPickup(Int32 id, bool owned, Int32 header, LightObj & payload);
VehicleInst & AllocVehicle(Int32 id, bool owned, Int32 header, LightObj & payload);
/* --------------------------------------------------------------------------------------------
* Entity deallocator.
*/
void DeallocBlip(Int32 id, bool destroy, Int32 header, LightObj & payload);
void DeallocCheckpoint(Int32 id, bool destroy, Int32 header, LightObj & payload);
void DeallocKeybind(Int32 id, bool destroy, Int32 header, LightObj & payload);
void DeallocObject(Int32 id, bool destroy, Int32 header, LightObj & payload);
void DeallocPickup(Int32 id, bool destroy, Int32 header, LightObj & payload);
void DeallocVehicle(Int32 id, bool destroy, Int32 header, LightObj & payload);
public:
/* --------------------------------------------------------------------------------------------
* Entity creators.
*/
LightObj & NewBlip(Int32 index, Int32 world, Float32 x, Float32 y, Float32 z,
Int32 scale, Uint32 color, Int32 sprid,
Int32 header, LightObj & payload);
LightObj & NewCheckpoint(Int32 player, Int32 world, bool sphere, Float32 x, Float32 y, Float32 z,
Uint8 r, Uint8 g, Uint8 b, Uint8 a, Float32 radius,
Int32 header, LightObj & payload);
LightObj & NewKeybind(Int32 slot, bool release,
Int32 primary, Int32 secondary, Int32 alternative,
Int32 header, LightObj & payload);
LightObj & NewObject(Int32 model, Int32 world, Float32 x, Float32 y, Float32 z,
Int32 alpha, Int32 header, LightObj & payload);
LightObj & NewPickup(Int32 model, Int32 world, Int32 quantity,
Float32 x, Float32 y, Float32 z, Int32 alpha, bool automatic,
Int32 header, LightObj & payload);
LightObj & NewSprite(Int32 index, CSStr file, Int32 xp, Int32 yp,
Int32 xr, Int32 yr, Float32 angle, Int32 alpha, bool rel,
Int32 header, LightObj & payload);
LightObj & NewTextdraw(Int32 index, CSStr text, Int32 xp, Int32 yp,
Uint32 color, bool rel, Int32 header, LightObj & payload);
LightObj & NewVehicle(Int32 model, Int32 world, Float32 x, Float32 y, Float32 z,
Float32 angle, Int32 primary, Int32 secondary,
Int32 header, LightObj & payload);
/* --------------------------------------------------------------------------------------------
* Entity destroyers.
*/
bool DelBlip(Int32 id, Int32 header, LightObj & payload);
bool DelCheckpoint(Int32 id, Int32 header, LightObj & payload);
bool DelKeybind(Int32 id, Int32 header, LightObj & payload);
bool DelObject(Int32 id, Int32 header, LightObj & payload);
bool DelPickup(Int32 id, Int32 header, LightObj & payload);
bool DelVehicle(Int32 id, Int32 header, LightObj & payload);
/* --------------------------------------------------------------------------------------------
* Entity retrievers.
*/
BlipInst & GetBlip(Int32 id) { return m_Blips.at(id); }
CheckpointInst & GetCheckpoint(Int32 id) { return m_Checkpoints.at(id); }
KeybindInst & GetKeybind(Int32 id) { return m_Keybinds.at(id); }
ObjectInst & GetObject(Int32 id) { return m_Objects.at(id); }
PickupInst & GetPickup(Int32 id) { return m_Pickups.at(id); }
PlayerInst & GetPlayer(Int32 id) { return m_Players.at(id); }
VehicleInst & GetVehicle(Int32 id) { return m_Vehicles.at(id); }
/* --------------------------------------------------------------------------------------------
* Pool retrievers.
*/
const Blips & GetBlips() const { return m_Blips; }
const Checkpoints & GetCheckpoints() const { return m_Checkpoints; }
const Keybinds & GetKeybinds() const { return m_Keybinds; }
const Objects & GetObjects() const { return m_Objects; }
const Pickups & GetPickups() const { return m_Pickups; }
const Players & GetPlayers() const { return m_Players; }
const Vehicles & GetVehicles() const { return m_Vehicles; }
/* --------------------------------------------------------------------------------------------
* Null instance retrievers.
*/
LightObj & GetNullBlip() { return m_NullBlip; }
LightObj & GetNullCheckpoint() { return m_NullCheckpoint; }
LightObj & GetNullKeybind() { return m_NullKeybind; }
LightObj & GetNullObject() { return m_NullObject; }
LightObj & GetNullPickup() { return m_NullPickup; }
LightObj & GetNullPlayer() { return m_NullPlayer; }
LightObj & GetNullVehicle() { return m_NullVehicle; }
/* --------------------------------------------------------------------------------------------
* Container cleaner.
*/
void ClearContainer(EntityType type);
protected:
/* --------------------------------------------------------------------------------------------
* Signal initialization and termination.
*/
void InitEvents();
void DropEvents();
public:
/* --------------------------------------------------------------------------------------------
* Player lifetime management.
*/
void ConnectPlayer(Int32 id, Int32 header, LightObj & payload);
void DisconnectPlayer(Int32 id, Int32 header, LightObj & payload);
/* --------------------------------------------------------------------------------------------
* Emit a custom event.
*/
void EmitCustomEvent(Int32 group, Int32 header, LightObj & payload);
/* --------------------------------------------------------------------------------------------
* Server events.
*/
void EmitBlipCreated(Int32 blip, Int32 header, LightObj & payload);
void EmitCheckpointCreated(Int32 forcefield, Int32 header, LightObj & payload);
void EmitKeybindCreated(Int32 keybind, Int32 header, LightObj & payload);
void EmitObjectCreated(Int32 object, Int32 header, LightObj & payload);
void EmitPickupCreated(Int32 pickup, Int32 header, LightObj & payload);
void EmitPlayerCreated(Int32 player, Int32 header, LightObj & payload);
void EmitVehicleCreated(Int32 vehicle, Int32 header, LightObj & payload);
void EmitBlipDestroyed(Int32 blip, Int32 header, LightObj & payload);
void EmitCheckpointDestroyed(Int32 forcefield, Int32 header, LightObj & payload);
void EmitKeybindDestroyed(Int32 keybind, Int32 header, LightObj & payload);
void EmitObjectDestroyed(Int32 object, Int32 header, LightObj & payload);
void EmitPickupDestroyed(Int32 pickup, Int32 header, LightObj & payload);
void EmitPlayerDestroyed(Int32 player, Int32 header, LightObj & payload);
void EmitVehicleDestroyed(Int32 vehicle, Int32 header, LightObj & payload);
void EmitBlipCustom(Int32 blip, Int32 header, LightObj & payload);
void EmitCheckpointCustom(Int32 forcefield, Int32 header, LightObj & payload);
void EmitKeybindCustom(Int32 keybind, Int32 header, LightObj & payload);
void EmitObjectCustom(Int32 object, Int32 header, LightObj & payload);
void EmitPickupCustom(Int32 pickup, Int32 header, LightObj & payload);
void EmitPlayerCustom(Int32 player, Int32 header, LightObj & payload);
void EmitVehicleCustom(Int32 vehicle, Int32 header, LightObj & payload);
void EmitServerStartup();
void EmitServerShutdown();
void EmitServerFrame(Float32 elapsed_time);
void EmitPluginCommand(Uint32 command_identifier, CCStr message);
void EmitIncomingConnection(CStr player_name, size_t name_buffer_size, CCStr user_password, CCStr ip_address);
void EmitPlayerRequestClass(Int32 player_id, Int32 offset);
void EmitPlayerRequestSpawn(Int32 player_id);
void EmitPlayerSpawn(Int32 player_id);
void EmitPlayerWasted(Int32 player_id, Int32 reason);
void EmitPlayerKilled(Int32 player_id, Int32 killer_id, Int32 reason, vcmpBodyPart body_part, bool team_kill);
void EmitPlayerEmbarking(Int32 player_id, Int32 vehicle_id, Int32 slot_index);
void EmitPlayerEmbarked(Int32 player_id, Int32 vehicle_id, Int32 slot_index);
void EmitPlayerDisembark(Int32 player_id, Int32 vehicle_id);
void EmitPlayerRename(Int32 player_id, CCStr old_name, CCStr new_name);
void EmitPlayerState(Int32 player_id, Int32 old_state, Int32 new_state);
void EmitStateNone(Int32 player_id, Int32 old_state);
void EmitStateNormal(Int32 player_id, Int32 old_state);
void EmitStateAim(Int32 player_id, Int32 old_state);
void EmitStateDriver(Int32 player_id, Int32 old_state);
void EmitStatePassenger(Int32 player_id, Int32 old_state);
void EmitStateEnterDriver(Int32 player_id, Int32 old_state);
void EmitStateEnterPassenger(Int32 player_id, Int32 old_state);
void EmitStateExit(Int32 player_id, Int32 old_state);
void EmitStateUnspawned(Int32 player_id, Int32 old_state);
void EmitPlayerAction(Int32 player_id, Int32 old_action, Int32 new_action);
void EmitActionNone(Int32 player_id, Int32 old_action);
void EmitActionNormal(Int32 player_id, Int32 old_action);
void EmitActionAiming(Int32 player_id, Int32 old_action);
void EmitActionShooting(Int32 player_id, Int32 old_action);
void EmitActionJumping(Int32 player_id, Int32 old_action);
void EmitActionLieDown(Int32 player_id, Int32 old_action);
void EmitActionGettingUp(Int32 player_id, Int32 old_action);
void EmitActionJumpVehicle(Int32 player_id, Int32 old_action);
void EmitActionDriving(Int32 player_id, Int32 old_action);
void EmitActionDying(Int32 player_id, Int32 old_action);
void EmitActionWasted(Int32 player_id, Int32 old_action);
void EmitActionEmbarking(Int32 player_id, Int32 old_action);
void EmitActionDisembarking(Int32 player_id, Int32 old_action);
void EmitPlayerBurning(Int32 player_id, bool is_on_fire);
void EmitPlayerCrouching(Int32 player_id, bool is_crouching);
void EmitPlayerGameKeys(Int32 player_id, Uint32 old_keys, Uint32 new_keys);
void EmitPlayerStartTyping(Int32 player_id);
void EmitPlayerStopTyping(Int32 player_id);
void EmitPlayerAway(Int32 player_id, bool is_away);
void EmitPlayerMessage(Int32 player_id, CCStr message);
void EmitPlayerCommand(Int32 player_id, CCStr message);
void EmitPlayerPrivateMessage(Int32 player_id, Int32 target_player_id, CCStr message);
void EmitPlayerKeyPress(Int32 player_id, Int32 bind_id);
void EmitPlayerKeyRelease(Int32 player_id, Int32 bind_id);
void EmitPlayerSpectate(Int32 player_id, Int32 target_player_id);
void EmitPlayerUnspectate(Int32 player_id);
void EmitPlayerCrashreport(Int32 player_id, CCStr report);
void EmitPlayerModuleList(Int32 player_id, CCStr list);
void EmitVehicleExplode(Int32 vehicle_id);
void EmitVehicleRespawn(Int32 vehicle_id);
void EmitObjectShot(Int32 object_id, Int32 player_id, Int32 weapon_id);
void EmitObjectTouched(Int32 object_id, Int32 player_id);
void EmitPickupClaimed(Int32 pickup_id, Int32 player_id);
void EmitPickupCollected(Int32 pickup_id, Int32 player_id);
void EmitPickupRespawn(Int32 pickup_id);
void EmitCheckpointEntered(Int32 checkpoint_id, Int32 player_id);
void EmitCheckpointExited(Int32 checkpoint_id, Int32 player_id);
/* --------------------------------------------------------------------------------------------
* Miscellaneous events.
*/
void EmitCheckpointWorld(Int32 checkpoint_id, Int32 old_world, Int32 new_world);
void EmitCheckpointRadius(Int32 checkpoint_id, Float32 old_radius, Float32 new_radius);
void EmitObjectWorld(Int32 object_id, Int32 old_world, Int32 new_world);
void EmitObjectAlpha(Int32 object_id, Int32 old_alpha, Int32 new_alpha, Int32 time);
void EmitPickupWorld(Int32 pickup_id, Int32 old_world, Int32 new_world);
void EmitPickupAlpha(Int32 pickup_id, Int32 old_alpha, Int32 new_alpha);
void EmitPickupAutomatic(Int32 pickup_id, bool old_status, bool new_status);
void EmitPickupAutoTimer(Int32 pickup_id, Int32 old_timer, Int32 new_timer);
void EmitPickupOption(Int32 pickup_id, Int32 option_id, bool value, Int32 header, LightObj & payload);
void EmitObjectReport(Int32 object_id, bool old_status, bool new_status, bool touched);
void EmitPlayerHealth(Int32 player_id, Float32 old_health, Float32 new_health);
void EmitPlayerArmour(Int32 player_id, Float32 old_armour, Float32 new_armour);
void EmitPlayerWeapon(Int32 player_id, Int32 old_weapon, Int32 new_weapon);
void EmitPlayerHeading(Int32 player_id, Float32 old_heading, Float32 new_heading);
void EmitPlayerPosition(Int32 player_id);
void EmitPlayerOption(Int32 player_id, Int32 option_id, bool value, Int32 header, LightObj & payload);
void EmitPlayerAdmin(Int32 player_id, bool old_status, bool new_status);
void EmitPlayerWorld(Int32 player_id, Int32 old_world, Int32 new_world, bool secondary);
void EmitPlayerTeam(Int32 player_id, Int32 old_team, Int32 new_team);
void EmitPlayerSkin(Int32 player_id, Int32 old_skin, Int32 new_skin);
void EmitPlayerMoney(Int32 player_id, Int32 old_money, Int32 new_money);
void EmitPlayerScore(Int32 player_id, Int32 old_score, Int32 new_score);
void EmitPlayerWantedLevel(Int32 player_id, Int32 old_level, Int32 new_level);
void EmitPlayerImmunity(Int32 player_id, Int32 old_immunity, Int32 new_immunity);
void EmitPlayerAlpha(Int32 player_id, Int32 old_alpha, Int32 new_alpha, Int32 fade);
void EmitPlayerEnterArea(Int32 player_id, LightObj & area_obj);
void EmitPlayerLeaveArea(Int32 player_id, LightObj & area_obj);
void EmitVehicleColor(Int32 vehicle_id, Int32 changed);
void EmitVehicleHealth(Int32 vehicle_id, Float32 old_health, Float32 new_health);
void EmitVehiclePosition(Int32 vehicle_id);
void EmitVehicleRotation(Int32 vehicle_id);
void EmitVehicleOption(Int32 vehicle_id, Int32 option_id, bool value, Int32 header, LightObj & payload);
void EmitVehicleWorld(Int32 vehicle_id, Int32 old_world, Int32 new_world);
void EmitVehicleImmunity(Int32 vehicle_id, Int32 old_immunity, Int32 new_immunity);
void EmitVehiclePartStatus(Int32 vehicle_id, Int32 part, Int32 old_status, Int32 new_status);
void EmitVehicleTyreStatus(Int32 vehicle_id, Int32 tyre, Int32 old_status, Int32 new_status);
void EmitVehicleDamageData(Int32 vehicle_id, Uint32 old_data, Uint32 new_data);
void EmitVehicleRadio(Int32 vehicle_id, Int32 old_radio, Int32 new_radio);
void EmitVehicleHandlingRule(Int32 vehicle_id, Int32 rule, Float32 old_data, Float32 new_data);
void EmitVehicleEnterArea(Int32 player_id, LightObj & area_obj);
void EmitVehicleLeaveArea(Int32 player_id, LightObj & area_obj);
void EmitServerOption(Int32 option, bool value, Int32 header, LightObj & payload);
void EmitScriptReload(Int32 header, LightObj & payload);
void EmitScriptLoaded();
/* --------------------------------------------------------------------------------------------
* Entity pool changes events.
*/
void EmitEntityPool(vcmpEntityPool entity_type, Int32 entity_id, bool is_deleted);
/* --------------------------------------------------------------------------------------------
* Entity streaming changes events.
*/
void EmitCheckpointStream(int32_t player_id, int32_t entity_id, bool is_deleted);
void EmitObjectStream(int32_t player_id, int32_t entity_id, bool is_deleted);
void EmitPickupStream(int32_t player_id, int32_t entity_id, bool is_deleted);
void EmitPlayerStream(int32_t player_id, int32_t entity_id, bool is_deleted);
void EmitVehicleStream(int32_t player_id, int32_t entity_id, bool is_deleted);
void EmitEntityStreaming(int32_t player_id, int32_t entity_id, vcmpEntityPool entity_type, bool is_deleted);
/* --------------------------------------------------------------------------------------------
* Entity update events.
*/
void EmitPlayerUpdate(Int32 player_id, vcmpPlayerUpdate update_type);
void EmitVehicleUpdate(Int32 vehicle_id, vcmpVehicleUpdate update_type);
/* --------------------------------------------------------------------------------------------
* Client data streams event.
*/
void EmitClientScriptData(Int32 player_id, const uint8_t * data, size_t size);
public:
/* --------------------------------------------------------------------------------------------
* Module signals.
*/
SignalPair mOnPreLoad;
SignalPair mOnPostLoad;
SignalPair mOnUnload;
/* --------------------------------------------------------------------------------------------
* Server signals.
*/
SignalPair mOnCustomEvent;
SignalPair mOnBlipCreated;
SignalPair mOnCheckpointCreated;
SignalPair mOnKeybindCreated;
SignalPair mOnObjectCreated;
SignalPair mOnPickupCreated;
SignalPair mOnPlayerCreated;
SignalPair mOnVehicleCreated;
SignalPair mOnBlipDestroyed;
SignalPair mOnCheckpointDestroyed;
SignalPair mOnKeybindDestroyed;
SignalPair mOnObjectDestroyed;
SignalPair mOnPickupDestroyed;
SignalPair mOnPlayerDestroyed;
SignalPair mOnVehicleDestroyed;
SignalPair mOnBlipCustom;
SignalPair mOnCheckpointCustom;
SignalPair mOnKeybindCustom;
SignalPair mOnObjectCustom;
SignalPair mOnPickupCustom;
SignalPair mOnPlayerCustom;
SignalPair mOnVehicleCustom;
SignalPair mOnCheckpointStream;
SignalPair mOnObjectStream;
SignalPair mOnPickupStream;
SignalPair mOnPlayerStream;
SignalPair mOnVehicleStream;
SignalPair mOnServerStartup;
SignalPair mOnServerShutdown;
SignalPair mOnServerFrame;
SignalPair mOnIncomingConnection;
SignalPair mOnPlayerRequestClass;
SignalPair mOnPlayerRequestSpawn;
SignalPair mOnPlayerSpawn;
SignalPair mOnPlayerWasted;
SignalPair mOnPlayerKilled;
SignalPair mOnPlayerEmbarking;
SignalPair mOnPlayerEmbarked;
SignalPair mOnPlayerDisembark;
SignalPair mOnPlayerRename;
SignalPair mOnPlayerState;
SignalPair mOnStateNone;
SignalPair mOnStateNormal;
SignalPair mOnStateAim;
SignalPair mOnStateDriver;
SignalPair mOnStatePassenger;
SignalPair mOnStateEnterDriver;
SignalPair mOnStateEnterPassenger;
SignalPair mOnStateExit;
SignalPair mOnStateUnspawned;
SignalPair mOnPlayerAction;
SignalPair mOnActionNone;
SignalPair mOnActionNormal;
SignalPair mOnActionAiming;
SignalPair mOnActionShooting;
SignalPair mOnActionJumping;
SignalPair mOnActionLieDown;
SignalPair mOnActionGettingUp;
SignalPair mOnActionJumpVehicle;
SignalPair mOnActionDriving;
SignalPair mOnActionDying;
SignalPair mOnActionWasted;
SignalPair mOnActionEmbarking;
SignalPair mOnActionDisembarking;
SignalPair mOnPlayerBurning;
SignalPair mOnPlayerCrouching;
SignalPair mOnPlayerGameKeys;
SignalPair mOnPlayerStartTyping;
SignalPair mOnPlayerStopTyping;
SignalPair mOnPlayerAway;
SignalPair mOnPlayerMessage;
SignalPair mOnPlayerCommand;
SignalPair mOnPlayerPrivateMessage;
SignalPair mOnPlayerKeyPress;
SignalPair mOnPlayerKeyRelease;
SignalPair mOnPlayerSpectate;
SignalPair mOnPlayerUnspectate;
SignalPair mOnPlayerCrashreport;
SignalPair mOnPlayerModuleList;
SignalPair mOnVehicleExplode;
SignalPair mOnVehicleRespawn;
SignalPair mOnObjectShot;
SignalPair mOnObjectTouched;
SignalPair mOnObjectWorld;
SignalPair mOnObjectAlpha;
SignalPair mOnObjectReport;
SignalPair mOnPickupClaimed;
SignalPair mOnPickupCollected;
SignalPair mOnPickupRespawn;
SignalPair mOnPickupWorld;
SignalPair mOnPickupAlpha;
SignalPair mOnPickupAutomatic;
SignalPair mOnPickupAutoTimer;
SignalPair mOnPickupOption;
SignalPair mOnCheckpointEntered;
SignalPair mOnCheckpointExited;
SignalPair mOnCheckpointWorld;
SignalPair mOnCheckpointRadius;
SignalPair mOnEntityPool;
SignalPair mOnClientScriptData;
SignalPair mOnPlayerUpdate;
SignalPair mOnVehicleUpdate;
SignalPair mOnPlayerHealth;
SignalPair mOnPlayerArmour;
SignalPair mOnPlayerWeapon;
SignalPair mOnPlayerHeading;
SignalPair mOnPlayerPosition;
SignalPair mOnPlayerOption;
SignalPair mOnPlayerAdmin;
SignalPair mOnPlayerWorld;
SignalPair mOnPlayerTeam;
SignalPair mOnPlayerSkin;
SignalPair mOnPlayerMoney;
SignalPair mOnPlayerScore;
SignalPair mOnPlayerWantedLevel;
SignalPair mOnPlayerImmunity;
SignalPair mOnPlayerAlpha;
SignalPair mOnPlayerEnterArea;
SignalPair mOnPlayerLeaveArea;
SignalPair mOnVehicleColor;
SignalPair mOnVehicleHealth;
SignalPair mOnVehiclePosition;
SignalPair mOnVehicleRotation;
SignalPair mOnVehicleOption;
SignalPair mOnVehicleWorld;
SignalPair mOnVehicleImmunity;
SignalPair mOnVehiclePartStatus;
SignalPair mOnVehicleTyreStatus;
SignalPair mOnVehicleDamageData;
SignalPair mOnVehicleRadio;
SignalPair mOnVehicleHandlingRule;
SignalPair mOnVehicleEnterArea;
SignalPair mOnVehicleLeaveArea;
SignalPair mOnEntityStream;
SignalPair mOnServerOption;
SignalPair mOnScriptReload;
SignalPair mOnScriptLoaded;
};
/* ------------------------------------------------------------------------------------------------
* Structure used to preserve the core state across recursive event calls from the server.
*/
struct CoreState
{
/* --------------------------------------------------------------------------------------------
* Backup the current core state.
*/
CoreState()
: m_State(Core::Get().GetState())
{
//...
}
/* --------------------------------------------------------------------------------------------
* Backup the current core state and set the given state.
*/
CoreState(int s)
: m_State(Core::Get().GetState())
{
Core::Get().SetState(s);
}
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
CoreState(const CoreState & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor (disabled).
*/
CoreState(CoreState && o) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor. Restore the grabbed core state.
*/
~CoreState()
{
Core::Get().SetState(m_State);
}
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
CoreState & operator = (const CoreState & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator (disabled).
*/
CoreState & operator = (CoreState && o) = delete;
/* --------------------------------------------------------------------------------------------
* Retrieve the guarded state.
*/
int GetValue() const
{
return m_State;
}
protected:
int m_State; // The core state at the time when this instance was created.
};
} // Namespace:: SqMod
#endif // _CORE_HPP_