mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2024-11-08 08:47:17 +01:00
483 lines
14 KiB
C++
483 lines
14 KiB
C++
#include "Common.hpp"
|
|
#include "Logger.hpp"
|
|
#include "Core.hpp"
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
#include <cstdio>
|
|
|
|
#if defined(_WIN32)
|
|
#include <winsock2.h>
|
|
#endif // _WIN32
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
namespace SqMod {
|
|
|
|
// --------------------------------------------------------------------------------------------
|
|
PluginFuncs* _Func = 0;
|
|
PluginCallbacks* _Clbk = 0;
|
|
PluginInfo* _Info = 0;
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void BindCallbacks();
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
SQMOD_API_EXPORT unsigned int VcmpPluginInit(PluginFuncs * funcs, PluginCallbacks * calls, PluginInfo * info)
|
|
{
|
|
#if defined(_WIN32)
|
|
WSADATA wsaData;
|
|
#endif // _WIN32
|
|
// Verify that core components are working
|
|
if (!_Log)
|
|
{
|
|
puts("[SQMOD] Unable to start because the logging class could not be instantiated");
|
|
return SQMOD_FAILURE;
|
|
}
|
|
else if (!_Core)
|
|
{
|
|
puts("[SQMOD] Unable to start because the central core class could not be instantiated");
|
|
return SQMOD_FAILURE;
|
|
}
|
|
#if defined(_WIN32)
|
|
// Initialize the sockets on windows
|
|
else if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
|
|
{
|
|
puts("[SQMOD] Unable to start because the windows sockets could not be initialized");
|
|
return SQMOD_FAILURE;
|
|
}
|
|
#endif // _WIN32
|
|
else
|
|
{
|
|
_Func = funcs;
|
|
_Clbk = calls;
|
|
_Info = info;
|
|
|
|
_Info->uPluginVer = SQMOD_VERSION;
|
|
std::strcpy(_Info->szName, SQMOD_NAME);
|
|
}
|
|
|
|
_Log->Msg("%s", CenterStr("STARTUP", '*'));
|
|
|
|
_Log->Inf("%s", CenterStr(SQMOD_NAME, ' '));
|
|
_Log->Inf("%s", CenterStr(SQMOD_COPYRIGHT, ' '));
|
|
_Log->Inf("%s", CenterStr(SQMOD_VERSION_STR, ' '));
|
|
|
|
if (!_Core->Init())
|
|
{
|
|
_Log->Ftl("The plugin failed to initialize");
|
|
_Log->Msg("%s", CenterStr("ABORTING", '*'));
|
|
|
|
_Core->Deinit();
|
|
|
|
return SQMOD_FAILURE;
|
|
}
|
|
else if (_Clbk)
|
|
{
|
|
BindCallbacks();
|
|
}
|
|
else
|
|
{
|
|
_Log->Ftl("Unable to start because the server callbacks are missing");
|
|
|
|
return SQMOD_FAILURE;
|
|
}
|
|
|
|
return SQMOD_SUCCESS;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------------------
|
|
static int VC_InitServer(void)
|
|
{
|
|
if (_Core->Load())
|
|
{
|
|
_Core->OnServerStartup();
|
|
}
|
|
else
|
|
{
|
|
_Log->Ftl("Unable to load the plugin resources properly");
|
|
}
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static void VC_ShutdownServer(void)
|
|
{
|
|
_Core->OnServerShutdown();
|
|
_Core->Terminate();
|
|
}
|
|
|
|
static void VC_Frame(float delta)
|
|
{
|
|
_Core->OnServerFrame(delta);
|
|
}
|
|
|
|
static void VC_PlayerConnect(int player)
|
|
{
|
|
_Core->ConnectPlayer(player, SQMOD_CREATE_AUTOMATIC, NullData());
|
|
}
|
|
|
|
static void VC_PlayerDisconnect(int player, int reason)
|
|
{
|
|
_Core->DisconnectPlayer(player, reason, NullData());
|
|
}
|
|
|
|
static void VC_PlayerBeginTyping(int player)
|
|
{
|
|
_Core->OnPlayerStartTyping(player);
|
|
}
|
|
|
|
static void VC_PlayerEndTyping(int player)
|
|
{
|
|
_Core->OnPlayerStopTyping(player);
|
|
}
|
|
|
|
static int VC_PlayerRequestClass(int player, int offset)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnPlayerRequestClass(player, offset);
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static int VC_PlayerRequestSpawn(int player)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnPlayerRequestSpawn(player);
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static void VC_PlayerSpawn(int player)
|
|
{
|
|
_Core->OnPlayerSpawn(player);
|
|
}
|
|
|
|
static void VC_PlayerDeath(int player, int killer, int reason, int body_part)
|
|
{
|
|
if (_Func->IsPlayerConnected(killer))
|
|
{
|
|
_Core->OnPlayerKilled(player, killer, reason, body_part);
|
|
}
|
|
else
|
|
{
|
|
_Core->OnPlayerWasted(player, reason);
|
|
}
|
|
}
|
|
|
|
static void VC_PlayerUpdate(int player, int type)
|
|
{
|
|
_Core->OnPlayerUpdate(player, type);
|
|
}
|
|
|
|
static int VC_PlayerRequestEnter(int player, int vehicle, int slot)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnPlayerEmbarking(player, vehicle, slot);
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static void VC_PlayerEnterVehicle(int player, int vehicle, int slot)
|
|
{
|
|
_Core->OnPlayerEmbarked(player, vehicle, slot);
|
|
}
|
|
|
|
static void VC_PlayerExitVehicle(int player, int vehicle)
|
|
{
|
|
_Core->OnPlayerDisembark(player, vehicle);
|
|
}
|
|
|
|
static int VC_PickupClaimPicked(int pickup, int player)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnPickupClaimed(player, pickup);
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static void VC_PickupPickedUp(int pickup, int player)
|
|
{
|
|
_Core->OnPickupCollected(player, pickup);
|
|
}
|
|
|
|
static void VC_PickupRespawn(int pickup)
|
|
{
|
|
_Core->OnPickupRespawn(pickup);
|
|
}
|
|
|
|
static void VC_VehicleUpdate(int vehicle, int type)
|
|
{
|
|
_Core->OnVehicleUpdate(vehicle, type);
|
|
}
|
|
|
|
static void VC_VehicleExplode(int vehicle)
|
|
{
|
|
_Core->OnVehicleExplode(vehicle);
|
|
}
|
|
|
|
static void VC_VehicleRespawn(int vehicle)
|
|
{
|
|
_Core->OnVehicleRespawn(vehicle);
|
|
}
|
|
|
|
static void VC_ObjectShot(int object, int player, int weapon)
|
|
{
|
|
_Core->OnObjectShot(player, object, weapon);
|
|
}
|
|
|
|
static void VC_ObjectBump(int object, int player)
|
|
{
|
|
_Core->OnObjectBump(player, object);
|
|
}
|
|
|
|
static int VC_PublicMessage(int player, const char * text)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnPlayerChat(player, static_cast<const SQChar *>(text));
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static int VC_CommandMessage(int player, const char * text)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnPlayerCommand(player, static_cast<const SQChar *>(text));
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static int VC_PrivateMessage(int player, int target, const char * text)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnPlayerMessage(player, target, static_cast<const SQChar *>(text));
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static int VC_InternalCommand(unsigned int type, const char * text)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnInternalCommand(type, static_cast<const SQChar *>(text));
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static int VC_LoginAttempt(char * name, const char * passwd, const char * address)
|
|
{
|
|
_Core->SetState(SQMOD_SUCCESS);
|
|
_Core->OnLoginAttempt(static_cast<const SQChar *>(name), static_cast<const SQChar *>(passwd), static_cast<const SQChar *>(address));
|
|
return _Core->GetState();
|
|
}
|
|
|
|
static void VC_EntityPool(int type, int id, unsigned int deleted)
|
|
{
|
|
_Core->OnEntityPool(type, id, static_cast<bool>(deleted));
|
|
}
|
|
|
|
static void VC_KeyBindDown(int player, int bind)
|
|
{
|
|
_Core->OnPlayerKeyPress(player, bind);
|
|
}
|
|
|
|
static void VC_KeyBindUp(int player, int bind)
|
|
{
|
|
_Core->OnPlayerKeyRelease(player, bind);
|
|
}
|
|
|
|
static void VC_PlayerAway(int player, unsigned int status)
|
|
{
|
|
_Core->OnPlayerAway(player, static_cast<bool>(status));
|
|
}
|
|
|
|
static void VC_PlayerSpectate(int player, int target)
|
|
{
|
|
_Core->OnPlayerSpectate(player, target);
|
|
}
|
|
|
|
static void VC_PlayerCrashReport(int player, const char * report)
|
|
{
|
|
_Core->OnPlayerCrashreport(player, static_cast<const SQChar *>(report));
|
|
}
|
|
|
|
static void VC_ServerPerformanceReport(int count, const char ** description, unsigned long long * millis)
|
|
{
|
|
// Ignored for now...
|
|
SQMOD_UNUSED_VAR(count);
|
|
SQMOD_UNUSED_VAR(description);
|
|
SQMOD_UNUSED_VAR(millis);
|
|
}
|
|
|
|
static void VC_PlayerName(int player, const char * previous, const char * current)
|
|
{
|
|
_Core->OnPlayerName(player, static_cast<const SQChar *>(previous), static_cast<const SQChar *>(current));
|
|
}
|
|
|
|
static void VC_PlayerState(int player, int previous, int current)
|
|
{
|
|
_Core->OnPlayerState(player, previous, current);
|
|
|
|
switch (current)
|
|
{
|
|
case SQMOD_PLAYER_STATE_NONE:
|
|
_Core->OnStateNone(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_NORMAL:
|
|
_Core->OnStateNormal(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_SHOOTING:
|
|
_Core->OnStateShooting(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_DRIVER:
|
|
_Core->OnStateDriver(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_PASSENGER:
|
|
_Core->OnStatePassenger(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_ENTERING_AS_DRIVER:
|
|
_Core->OnStateEnterDriver(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_ENTERING_AS_PASSENGER:
|
|
_Core->OnStateEnterPassenger(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_EXITING_VEHICLE:
|
|
_Core->OnStateExitVehicle(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_STATE_UNSPAWNED:
|
|
_Core->OnStateUnspawned(player, previous);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void VC_PlayerAction(int player, int previous, int current)
|
|
{
|
|
_Core->OnPlayerAction(player, previous, current);
|
|
|
|
switch (current)
|
|
{
|
|
case SQMOD_PLAYER_ACTION_NONE:
|
|
_Core->OnActionNone(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_NORMAL:
|
|
_Core->OnActionNormal(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_AIMING:
|
|
_Core->OnActionAiming(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_SHOOTING:
|
|
_Core->OnActionShooting(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_JUMPING:
|
|
_Core->OnActionJumping(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_LYING_ON_GROUND:
|
|
_Core->OnActionLieDown(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_GETTING_UP:
|
|
_Core->OnActionGettingUp(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_JUMPING_FROM_VEHICLE:
|
|
_Core->OnActionJumpVehicle(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_DRIVING:
|
|
_Core->OnActionDriving(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_DYING:
|
|
_Core->OnActionDying(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_WASTED:
|
|
_Core->OnActionWasted(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_ENTERING_VEHICLE:
|
|
_Core->OnActionEmbarking(player, previous);
|
|
break;
|
|
case SQMOD_PLAYER_ACTION_EXITING_VEHICLE:
|
|
_Core->OnActionDisembarking(player, previous);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void VC_PlayerOnFire(int player, unsigned int state)
|
|
{
|
|
_Core->OnPlayerBurning(player, static_cast<bool>(state));
|
|
}
|
|
|
|
static void VC_PlayerCrouch(int player, unsigned int state)
|
|
{
|
|
_Core->OnPlayerCrouching(player, static_cast<bool>(state));
|
|
}
|
|
|
|
static void VC_PlayerGameKeys(int player, int previous, int current)
|
|
{
|
|
_Core->OnPlayerGameKeys(player, previous, current);
|
|
}
|
|
|
|
static void VC_OnCheckpointEntered(int checkpoint, int player)
|
|
{
|
|
_Core->OnCheckpointEntered(player, checkpoint);
|
|
}
|
|
|
|
static void VC_OnCheckpointExited(int checkpoint, int player)
|
|
{
|
|
_Core->OnCheckpointExited(player, checkpoint);
|
|
}
|
|
|
|
static void VC_OnSphereEntered(int sphere, int player)
|
|
{
|
|
_Core->OnSphereEntered(player, sphere);
|
|
}
|
|
|
|
static void VC_OnSphereExited(int sphere, int player)
|
|
{
|
|
_Core->OnSphereExited(player, sphere);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void BindCallbacks()
|
|
{
|
|
_Clbk->OnInitServer = VC_InitServer;
|
|
_Clbk->OnShutdownServer = VC_ShutdownServer;
|
|
_Clbk->OnFrame = VC_Frame;
|
|
_Clbk->OnPlayerConnect = VC_PlayerConnect;
|
|
_Clbk->OnPlayerDisconnect = VC_PlayerDisconnect;
|
|
_Clbk->OnPlayerBeginTyping = VC_PlayerBeginTyping;
|
|
_Clbk->OnPlayerEndTyping = VC_PlayerEndTyping;
|
|
_Clbk->OnPlayerRequestClass = VC_PlayerRequestClass;
|
|
_Clbk->OnPlayerRequestSpawn = VC_PlayerRequestSpawn;
|
|
_Clbk->OnPlayerSpawn = VC_PlayerSpawn;
|
|
_Clbk->OnPlayerDeath = VC_PlayerDeath;
|
|
_Clbk->OnPlayerUpdate = VC_PlayerUpdate;
|
|
_Clbk->OnPlayerRequestEnter = VC_PlayerRequestEnter;
|
|
_Clbk->OnPlayerEnterVehicle = VC_PlayerEnterVehicle;
|
|
_Clbk->OnPlayerExitVehicle = VC_PlayerExitVehicle;
|
|
_Clbk->OnPickupClaimPicked = VC_PickupClaimPicked;
|
|
_Clbk->OnPickupPickedUp = VC_PickupPickedUp;
|
|
_Clbk->OnPickupRespawn = VC_PickupRespawn;
|
|
_Clbk->OnVehicleUpdate = VC_VehicleUpdate;
|
|
_Clbk->OnVehicleExplode = VC_VehicleExplode;
|
|
_Clbk->OnVehicleRespawn = VC_VehicleRespawn;
|
|
_Clbk->OnObjectShot = VC_ObjectShot;
|
|
_Clbk->OnObjectBump = VC_ObjectBump;
|
|
_Clbk->OnPublicMessage = VC_PublicMessage;
|
|
_Clbk->OnCommandMessage = VC_CommandMessage;
|
|
_Clbk->OnPrivateMessage = VC_PrivateMessage;
|
|
_Clbk->OnInternalCommand = VC_InternalCommand;
|
|
_Clbk->OnLoginAttempt = VC_LoginAttempt;
|
|
_Clbk->OnEntityPoolChange = VC_EntityPool;
|
|
_Clbk->OnKeyBindDown = VC_KeyBindDown;
|
|
_Clbk->OnKeyBindUp = VC_KeyBindUp;
|
|
_Clbk->OnPlayerAwayChange = VC_PlayerAway;
|
|
_Clbk->OnPlayerSpectate = VC_PlayerSpectate;
|
|
_Clbk->OnPlayerCrashReport = VC_PlayerCrashReport;
|
|
_Clbk->OnServerPerformanceReport = VC_ServerPerformanceReport;
|
|
_Clbk->OnPlayerNameChange = VC_PlayerName;
|
|
_Clbk->OnPlayerStateChange = VC_PlayerState;
|
|
_Clbk->OnPlayerActionChange = VC_PlayerAction;
|
|
_Clbk->OnPlayerOnFireChange = VC_PlayerOnFire;
|
|
_Clbk->OnPlayerCrouchChange = VC_PlayerCrouch;
|
|
_Clbk->OnPlayerGameKeysChange = VC_PlayerGameKeys;
|
|
_Clbk->OnCheckpointEntered = VC_OnCheckpointEntered;
|
|
_Clbk->OnCheckpointExited = VC_OnCheckpointExited;
|
|
_Clbk->OnSphereEntered = VC_OnSphereEntered;
|
|
_Clbk->OnSphereExited = VC_OnSphereExited;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
SqObj & NullData()
|
|
{
|
|
static SqObj d;
|
|
d.Release();
|
|
return d;
|
|
}
|
|
|
|
} // Namespace:: SqMod
|