thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2025-01-18 19:47:15 +01:00
Code Releases Activity

More code cleanup.

Browse Source
This commit is contained in:
Sandu Liviu Catalin 2020-03-22 10:00:31 +02:00
parent 3225e119a2
commit 33f057ac15
16 changed files with 207 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
module/Core.hpp
View File

@ -1266,7 +1266,7 @@ public:
void EmitVehicleTyreStatus(Int32 vehicle_id, Int32 tyre, 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 EmitVehicleDamageData(Int32 vehicle_id, Uint32 old_data, Uint32 new_data);
void EmitVehicleRadio(Int32 vehicle_id, Int32 old_radio, Int32 new_radio); 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 EmitVehicleHandlingRule(Int32 vehicle_id, Int32 rule, SQFloat old_data, SQFloat new_data);
void EmitVehicleEnterArea(Int32 player_id, LightObj & area_obj); void EmitVehicleEnterArea(Int32 player_id, LightObj & area_obj);
void EmitVehicleLeaveArea(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 EmitServerOption(Int32 option, bool value, Int32 header, LightObj & payload);

2
module/Core/Events.inc
View File

@ -1258,7 +1258,7 @@ void Core::EmitVehicleRadio(Int32 vehicle_id, Int32 old_radio, Int32 new_radio)
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void Core::EmitVehicleHandlingRule(Int32 vehicle_id, Int32 rule, Float32 old_data, Float32 new_data) void Core::EmitVehicleHandlingRule(Int32 vehicle_id, Int32 rule, SQFloat old_data, SQFloat new_data)
{ {
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::VehicleHandlingRule(%d, %d, %f, %f)", vehicle_id, rule, old_data, new_data) SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::VehicleHandlingRule(%d, %d, %f, %f)", vehicle_id, rule, old_data, new_data)
VehicleInst & _vehicle = m_Vehicles.at(static_cast< size_t >(vehicle_id)); VehicleInst & _vehicle = m_Vehicles.at(static_cast< size_t >(vehicle_id));

19
module/Entity/Blip.cpp
View File

@ -33,12 +33,6 @@ CBlip::CBlip(Int32 id)
/* ... */ /* ... */
} }
// ------------------------------------------------------------------------------------------------
CBlip::~CBlip()
{
/* ... */
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const String & CBlip::ToString() const const String & CBlip::ToString() const
{ {
@ -56,7 +50,7 @@ void CBlip::SetTag(StackStrF & tag)
{ {
if (tag.mLen > 0) if (tag.mLen > 0)
{ {
m_Tag.assign(tag.mPtr, tag.mLen); m_Tag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
} }
else else
{ {
@ -228,7 +222,7 @@ Int32 CBlip::GetColorA() const
static LightObj & Blip_CreateEx(Int32 world, Float32 x, Float32 y, Float32 z, Int32 scale, static LightObj & Blip_CreateEx(Int32 world, Float32 x, Float32 y, Float32 z, Int32 scale,
Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid) Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid)
{ {
return Core::Get().NewBlip(-1, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, return Core::Get().NewBlip(-1, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, // NOLINT(hicpp-signed-bitwise)
SQMOD_CREATE_DEFAULT, NullLightObj()); SQMOD_CREATE_DEFAULT, NullLightObj());
} }
@ -236,7 +230,7 @@ static LightObj & Blip_CreateEx(Int32 world, Float32 x, Float32 y, Float32 z, In
Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid, Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid,
Int32 header, LightObj & payload) Int32 header, LightObj & payload)
{ {
return Core::Get().NewBlip(-1, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, return Core::Get().NewBlip(-1, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, // NOLINT(hicpp-signed-bitwise)
header, payload); header, payload);
} }
@ -244,7 +238,7 @@ static LightObj & Blip_CreateEx(Int32 world, Float32 x, Float32 y, Float32 z, In
static LightObj & Blip_CreateEx(Int32 index, Int32 world, Float32 x, Float32 y, Float32 z, static LightObj & Blip_CreateEx(Int32 index, Int32 world, Float32 x, Float32 y, Float32 z,
Int32 scale, Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid) Int32 scale, Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid)
{ {
return Core::Get().NewBlip(index, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, return Core::Get().NewBlip(index, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, // NOLINT(hicpp-signed-bitwise)
SQMOD_CREATE_DEFAULT, NullLightObj()); SQMOD_CREATE_DEFAULT, NullLightObj());
} }
@ -252,7 +246,7 @@ static LightObj & Blip_CreateEx(Int32 index, Int32 world, Float32 x, Float32 y,
Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid, Uint8 r, Uint8 g, Uint8 b, Uint8 a, Int32 sprid,
Int32 header, LightObj & payload) Int32 header, LightObj & payload)
{ {
return Core::Get().NewBlip(index, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, return Core::Get().NewBlip(index, world, x, y, z, scale, SQMOD_PACK_RGBA(r, g, b, a), sprid, // NOLINT(hicpp-signed-bitwise)
header, payload); header, payload);
} }
@ -287,7 +281,10 @@ static LightObj & Blip_Create(Int32 index, Int32 world, const Vector3 & pos, Int
} }
// ================================================================================================ // ================================================================================================
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void Register_CBlip(HSQUIRRELVM vm) void Register_CBlip(HSQUIRRELVM vm)
#pragma clang diagnostic pop
{ {
RootTable(vm).Bind(Typename::Str, RootTable(vm).Bind(Typename::Str,
Class< CBlip, NoConstructor< CBlip > >(vm, Typename::Str) Class< CBlip, NoConstructor< CBlip > >(vm, Typename::Str)

7
module/Entity/Blip.hpp
View File

@ -34,7 +34,7 @@ private:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Base constructor. * Base constructor.
*/ */
CBlip(Int32 id); explicit CBlip(Int32 id);
public: public:
@ -53,11 +53,6 @@ public:
*/ */
CBlip(CBlip &&) = delete; CBlip(CBlip &&) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CBlip();
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled) * Copy assignment operator. (disabled)
*/ */

15
module/Entity/Checkpoint.cpp
View File

@ -36,12 +36,6 @@ CCheckpoint::CCheckpoint(Int32 id)
/* ... */ /* ... */
} }
// ------------------------------------------------------------------------------------------------
CCheckpoint::~CCheckpoint()
{
/* ... */
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const String & CCheckpoint::ToString() const const String & CCheckpoint::ToString() const
{ {
@ -59,7 +53,7 @@ void CCheckpoint::SetTag(StackStrF & tag)
{ {
if (tag.mLen > 0) if (tag.mLen > 0)
{ {
m_Tag.assign(tag.mPtr, tag.mLen); m_Tag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
} }
else else
{ {
@ -185,8 +179,8 @@ Color4 CCheckpoint::GetColor() const
// Query the server for the color values // Query the server for the color values
_Func->GetCheckPointColour(m_ID, &r, &g, &b, &a); _Func->GetCheckPointColour(m_ID, &r, &g, &b, &a);
// Return the requested information // Return the requested information
return Color4(ConvTo< Color4::Value >::From(r), ConvTo< Color4::Value >::From(g), return {ConvTo< Color4::Value >::From(r), ConvTo< Color4::Value >::From(g),
ConvTo< Color4::Value >::From(b), ConvTo< Color4::Value >::From(a)); ConvTo< Color4::Value >::From(b), ConvTo< Color4::Value >::From(a)};
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -508,7 +502,10 @@ static LightObj & Checkpoint_Create(Int32 world, bool sphere, const Vector3 & po
} }
// ================================================================================================ // ================================================================================================
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void Register_CCheckpoint(HSQUIRRELVM vm) void Register_CCheckpoint(HSQUIRRELVM vm)
#pragma clang diagnostic pop
{ {
RootTable(vm).Bind(Typename::Str, RootTable(vm).Bind(Typename::Str,
Class< CCheckpoint, NoConstructor< CCheckpoint > >(vm, Typename::Str) Class< CCheckpoint, NoConstructor< CCheckpoint > >(vm, Typename::Str)

11
module/Entity/Checkpoint.hpp
View File

@ -11,8 +11,8 @@ namespace SqMod {
*/ */
enum CheckpointCircularLocks enum CheckpointCircularLocks
{ {
CHECKPOINTCL_EMIT_CHECKPOINT_WORLD = (1 << 0), CHECKPOINTCL_EMIT_CHECKPOINT_WORLD = (1u << 0u),
CHECKPOINTCL_EMIT_CHECKPOINT_RADIUS = (1 << 1) CHECKPOINTCL_EMIT_CHECKPOINT_RADIUS = (1u << 1u)
}; };
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
@ -48,7 +48,7 @@ private:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Base constructor. * Base constructor.
*/ */
CCheckpoint(Int32 id); explicit CCheckpoint(Int32 id);
public: public:
@ -67,11 +67,6 @@ public:
*/ */
CCheckpoint(CCheckpoint &&) = delete; CCheckpoint(CCheckpoint &&) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CCheckpoint();
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled) * Copy assignment operator. (disabled)
*/ */

13
module/Entity/Keybind.cpp
View File

@ -33,12 +33,6 @@ CKeybind::CKeybind(Int32 id)
/* ... */ /* ... */
} }
// ------------------------------------------------------------------------------------------------
CKeybind::~CKeybind()
{
/* ... */
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const String & CKeybind::ToString() const const String & CKeybind::ToString() const
{ {
@ -56,7 +50,7 @@ void CKeybind::SetTag(StackStrF & tag)
{ {
if (tag.mLen > 0) if (tag.mLen > 0)
{ {
m_Tag.assign(tag.mPtr, tag.mLen); m_Tag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
} }
else else
{ {
@ -149,7 +143,7 @@ bool CKeybind::IsRelease() const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return Core::Get().GetKeybind(m_ID).mRelease; return static_cast< bool >(Core::Get().GetKeybind(m_ID).mRelease);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -186,7 +180,10 @@ static SQInteger Keybind_UnusedSlot()
} }
// ================================================================================================ // ================================================================================================
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void Register_CKeybind(HSQUIRRELVM vm) void Register_CKeybind(HSQUIRRELVM vm)
#pragma clang diagnostic pop
{ {
RootTable(vm).Bind(Typename::Str, RootTable(vm).Bind(Typename::Str,
Class< CKeybind, NoConstructor< CKeybind > >(vm, Typename::Str) Class< CKeybind, NoConstructor< CKeybind > >(vm, Typename::Str)

7
module/Entity/Keybind.hpp
View File

@ -34,7 +34,7 @@ private:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Base constructor. * Base constructor.
*/ */
CKeybind(Int32 id); explicit CKeybind(Int32 id);
public: public:
@ -53,11 +53,6 @@ public:
*/ */
CKeybind(CKeybind &&) = delete; CKeybind(CKeybind &&) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CKeybind();
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled) * Copy assignment operator. (disabled)
*/ */

15
module/Entity/Object.cpp
View File

@ -42,12 +42,6 @@ CObject::CObject(Int32 id)
/* ... */ /* ... */
} }
// ------------------------------------------------------------------------------------------------
CObject::~CObject()
{
/* ... */
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const String & CObject::ToString() const const String & CObject::ToString() const
{ {
@ -65,7 +59,7 @@ void CObject::SetTag(StackStrF & tag)
{ {
if (tag.mLen > 0) if (tag.mLen > 0)
{ {
m_Tag.assign(tag.mPtr, tag.mLen); m_Tag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
} }
else else
{ {
@ -407,7 +401,7 @@ void CObject::SetShotReport(bool toggle)
return; return;
} }
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetObjectShotReportEnabled(m_ID, toggle); _Func->SetObjectShotReportEnabled(m_ID, static_cast< uint8_t >(toggle));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT)) if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT))
{ {
@ -440,7 +434,7 @@ void CObject::SetTouchedReport(bool toggle)
return; return;
} }
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetObjectTouchedReportEnabled(m_ID, toggle); _Func->SetObjectTouchedReportEnabled(m_ID, static_cast< uint8_t >(toggle));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT)) if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT))
{ {
@ -867,7 +861,10 @@ static LightObj & Object_Create(Int32 model, Int32 world, const Vector3 & pos, I
} }
// ================================================================================================ // ================================================================================================
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void Register_CObject(HSQUIRRELVM vm) void Register_CObject(HSQUIRRELVM vm)
#pragma clang diagnostic pop
{ {
RootTable(vm).Bind(Typename::Str, RootTable(vm).Bind(Typename::Str,
Class< CObject, NoConstructor< CObject > >(vm, Typename::Str) Class< CObject, NoConstructor< CObject > >(vm, Typename::Str)

13
module/Entity/Object.hpp
View File

@ -11,9 +11,9 @@ namespace SqMod {
*/ */
enum ObjectCircularLocks enum ObjectCircularLocks
{ {
OBJECTCL_EMIT_OBJECT_WORLD = (1 << 0), OBJECTCL_EMIT_OBJECT_WORLD = (1u << 0u),
OBJECTCL_EMIT_OBJECT_ALPHA = (2 << 0), OBJECTCL_EMIT_OBJECT_ALPHA = (2u << 0u),
OBJECTCL_EMIT_OBJECT_REPORT = (3 << 0) OBJECTCL_EMIT_OBJECT_REPORT = (3u << 0u)
}; };
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
@ -49,7 +49,7 @@ private:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Base constructor. * Base constructor.
*/ */
CObject(Int32 id); explicit CObject(Int32 id);
public: public:
@ -86,11 +86,6 @@ public:
*/ */
CObject(CObject &&) = delete; CObject(CObject &&) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CObject();
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled) * Copy assignment operator. (disabled)
*/ */

19
module/Entity/Pickup.cpp
View File

@ -35,12 +35,6 @@ CPickup::CPickup(Int32 id)
/* ... */ /* ... */
} }
// ------------------------------------------------------------------------------------------------
CPickup::~CPickup()
{
/* ... */
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const String & CPickup::ToString() const const String & CPickup::ToString() const
{ {
@ -58,7 +52,7 @@ void CPickup::SetTag(StackStrF & tag)
{ {
if (tag.mLen > 0) if (tag.mLen > 0)
{ {
m_Tag.assign(tag.mPtr, tag.mLen); m_Tag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
} }
else else
{ {
@ -153,7 +147,7 @@ void CPickup::SetOption(Int32 option_id, bool toggle)
const bool value = _Func->GetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id)); const bool value = _Func->GetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id));
// Attempt to modify the current value of the specified option // Attempt to modify the current value of the specified option
if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id), if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id),
toggle) == vcmpErrorArgumentOutOfBounds) static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
{ {
STHROWF("Invalid option identifier: %d", option_id); STHROWF("Invalid option identifier: %d", option_id);
} }
@ -173,7 +167,7 @@ void CPickup::SetOptionEx(Int32 option_id, bool toggle, Int32 header, LightObj &
const bool value = _Func->GetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id)); const bool value = _Func->GetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id));
// Attempt to modify the current value of the specified option // Attempt to modify the current value of the specified option
if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id), if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id),
toggle) == vcmpErrorArgumentOutOfBounds) static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
{ {
STHROWF("Invalid option identifier: %d", option_id); STHROWF("Invalid option identifier: %d", option_id);
} }
@ -274,7 +268,7 @@ void CPickup::SetAutomatic(bool toggle)
return; return;
} }
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetPickupIsAutomatic(m_ID, toggle); _Func->SetPickupIsAutomatic(m_ID, static_cast< uint8_t >(toggle));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOMATIC)) if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOMATIC))
{ {
@ -307,7 +301,7 @@ void CPickup::SetAutoTimer(Int32 timer)
return; return;
} }
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetPickupAutoTimer(m_ID, timer); _Func->SetPickupAutoTimer(m_ID, static_cast< uint32_t >(timer));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOTIMER)) if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOTIMER))
{ {
@ -485,7 +479,10 @@ static LightObj & Pickup_Create(Int32 model, Int32 world, Int32 quantity, const
} }
// ================================================================================================ // ================================================================================================
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void Register_CPickup(HSQUIRRELVM vm) void Register_CPickup(HSQUIRRELVM vm)
#pragma clang diagnostic pop
{ {
RootTable(vm).Bind(Typename::Str, RootTable(vm).Bind(Typename::Str,
Class< CPickup, NoConstructor< CPickup > >(vm, Typename::Str) Class< CPickup, NoConstructor< CPickup > >(vm, Typename::Str)

17
module/Entity/Pickup.hpp
View File

@ -11,11 +11,11 @@ namespace SqMod {
*/ */
enum PickupCircularLocks enum PickupCircularLocks
{ {
PICKUPCL_EMIT_PICKUP_OPTION = (1 << 0), PICKUPCL_EMIT_PICKUP_OPTION = (1u << 0u),
PICKUPCL_EMIT_PICKUP_WORLD = (1 << 1), PICKUPCL_EMIT_PICKUP_WORLD = (1u << 1u),
PICKUPCL_EMIT_PICKUP_ALPHA = (1 << 2), PICKUPCL_EMIT_PICKUP_ALPHA = (1u << 2u),
PICKUPCL_EMIT_PICKUP_AUTOMATIC = (1 << 3), PICKUPCL_EMIT_PICKUP_AUTOMATIC = (1u << 3u),
PICKUPCL_EMIT_PICKUP_AUTOTIMER = (1 << 4) PICKUPCL_EMIT_PICKUP_AUTOTIMER = (1u << 4u)
}; };
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
@ -51,7 +51,7 @@ private:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Base constructor. * Base constructor.
*/ */
CPickup(Int32 id); explicit CPickup(Int32 id);
public: public:
@ -70,11 +70,6 @@ public:
*/ */
CPickup(CPickup &&) = delete; CPickup(CPickup &&) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CPickup();
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled) * Copy assignment operator. (disabled)
*/ */

95
module/Entity/Player.cpp
View File

@ -9,12 +9,6 @@
#include "Misc/Areas.hpp" #include "Misc/Areas.hpp"
#include "Misc/Tasks.hpp" #include "Misc/Tasks.hpp"
// ------------------------------------------------------------------------------------------------
#include <cstring>
// ------------------------------------------------------------------------------------------------
#include <sqstdstring.h>
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
namespace SqMod { namespace SqMod {
@ -59,18 +53,12 @@ CPlayer::CPlayer(Int32 id)
, mLimitPrefixPostfixMessage(true) , mLimitPrefixPostfixMessage(true)
{ {
// Reset message prefixes // Reset message prefixes
for (unsigned n = 0; n < SQMOD_PLAYER_MSG_PREFIXES; ++n) for (auto & mMessagePrefixe : mMessagePrefixes)
{ {
mMessagePrefixes[n].assign(_SC("")); mMessagePrefixe.assign(_SC(""));
} }
} }
// ------------------------------------------------------------------------------------------------
CPlayer::~CPlayer()
{
/* ... */
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const String & CPlayer::ToString() const const String & CPlayer::ToString() const
{ {
@ -88,7 +76,7 @@ void CPlayer::SetTag(StackStrF & tag)
{ {
if (tag.mLen > 0) if (tag.mLen > 0)
{ {
m_Tag.assign(tag.mPtr, tag.mLen); m_Tag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
} }
else else
{ {
@ -181,7 +169,7 @@ void CPlayer::SetAdmin(bool toggle)
return; return;
} }
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetPlayerAdmin(m_ID, toggle); _Func->SetPlayerAdmin(m_ID, static_cast< uint8_t >(toggle));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ADMIN)) if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ADMIN))
{ {
@ -387,7 +375,8 @@ void CPlayer::SetOptionEx(Int32 option_id, bool toggle, Int32 header, LightObj &
} }
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
else if (_Func->SetPlayerOption(m_ID, else if (_Func->SetPlayerOption(m_ID,
static_cast< vcmpPlayerOption >(option_id), toggle) == vcmpErrorArgumentOutOfBounds) static_cast< vcmpPlayerOption >(option_id),
static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
{ {
STHROWF("Invalid option identifier: %d", option_id); STHROWF("Invalid option identifier: %d", option_id);
} }
@ -616,7 +605,7 @@ void CPlayer::SetColorEx(Uint8 r, Uint8 g, Uint8 b) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetPlayerColour(m_ID, SQMOD_PACK_RGB(r, g, b)); _Func->SetPlayerColour(m_ID, SQMOD_PACK_RGB(r, g, b)); // NOLINT(hicpp-signed-bitwise)
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -783,12 +772,12 @@ Int32 CPlayer::GetPing() const
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
Float32 CPlayer::GetFPS() const SQFloat CPlayer::GetFPS() const
{ {
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return _Func->GetPlayerFPS(m_ID); return static_cast< SQFloat >(_Func->GetPlayerFPS(m_ID));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -844,7 +833,7 @@ void CPlayer::SetImmunity(Int32 flags)
// Grab the current value for this property // Grab the current value for this property
const Int32 current = _Func->GetPlayerImmunityFlags(m_ID); const Int32 current = _Func->GetPlayerImmunityFlags(m_ID);
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetPlayerImmunityFlags(m_ID, flags); _Func->SetPlayerImmunityFlags(m_ID, static_cast< uint32_t >(flags));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_IMMUNITY)) if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_IMMUNITY))
{ {
@ -981,7 +970,7 @@ void CPlayer::SetAlphaEx(Int32 alpha, Int32 fade)
return; return;
} }
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetPlayerAlpha(m_ID, alpha, fade); _Func->SetPlayerAlpha(m_ID, alpha, static_cast< uint32_t >(fade));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ALPHA)) if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ALPHA))
{ {
@ -1065,8 +1054,8 @@ bool CPlayer::Embark(CVehicle & vehicle) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
return (_Func->PutPlayerInVehicle(m_ID, vehicle.GetID(), 0, true, true) return (_Func->PutPlayerInVehicle(m_ID, vehicle.GetID(), 0,
!= vcmpErrorRequestDenied); static_cast< uint8_t >(true), static_cast< uint8_t >(true)) != vcmpErrorRequestDenied);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1080,8 +1069,8 @@ bool CPlayer::Embark(CVehicle & vehicle, Int32 slot, bool allocate, bool warp) c
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
return (_Func->PutPlayerInVehicle(m_ID, vehicle.GetID(), slot, allocate, warp) return (_Func->PutPlayerInVehicle(m_ID, vehicle.GetID(), slot,
!= vcmpErrorRequestDenied); static_cast< uint8_t >(allocate), static_cast< uint8_t >(warp)) != vcmpErrorRequestDenied);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1396,7 +1385,7 @@ void CPlayer::SetSpectatorID(SQInteger id) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Spectate the given target // Spectate the given target
_Func->SetPlayerSpectateTarget(m_ID, id); _Func->SetPlayerSpectateTarget(m_ID, static_cast< int32_t >(id));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1581,7 +1570,7 @@ bool CPlayer::GetCollideAreas() const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return (Core::Get().GetPlayer(m_ID).mFlags & ENF_AREA_TRACK); return static_cast< bool >(Core::Get().GetPlayer(m_ID).mFlags & ENF_AREA_TRACK);
} }
void CPlayer::SetCollideAreas(bool toggle) const void CPlayer::SetCollideAreas(bool toggle) const
@ -1695,7 +1684,8 @@ void CPlayer::SetMessagePrefix(Uint32 index, StackStrF & prefix)
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
mMessagePrefixes[index].assign(prefix.mPtr, ClampMin(prefix.mLen, 0)); mMessagePrefixes[index].assign(prefix.mPtr,
static_cast< size_t >(ClampMin(prefix.mLen, 0)));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1822,7 +1812,7 @@ void CPlayer::SetBufferCursor(Int32 pos)
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
m_Buffer.Move(pos); m_Buffer.Move(static_cast< Buffer::SzType >(pos));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1869,7 +1859,7 @@ void CPlayer::StreamString(StackStrF & val)
// Calculate the string length // Calculate the string length
Uint16 length = ConvTo< Uint16 >::From(val.mLen); Uint16 length = ConvTo< Uint16 >::From(val.mLen);
// Change the size endianness to big endian // Change the size endianness to big endian
Uint16 size = ((length >> 8) & 0xFF) | ((length & 0xFF) << 8); auto size = static_cast< Uint16 >(((length >> 8u) & 0xFFu) | ((length & 0xFFu) << 8u)); // NOLINT(hicpp-signed-bitwise)
// Write the size and then the string contents // Write the size and then the string contents
m_Buffer.Push< Uint16 >(size); m_Buffer.Push< Uint16 >(size);
m_Buffer.AppendS(val.mPtr, length); m_Buffer.AppendS(val.mPtr, length);
@ -1881,7 +1871,7 @@ void CPlayer::StreamRawString(StackStrF & val)
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Write the the string contents // Write the the string contents
m_Buffer.AppendS(val.mPtr, ClampMin(val.mLen, 0)); m_Buffer.AppendS(val.mPtr, static_cast< Buffer::SzType >(ClampMin(val.mLen, 0)));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -2024,7 +2014,7 @@ Int32 CPlayer::GetColorR() const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return static_cast< Int32 >((_Func->GetPlayerColour(m_ID) >> 16) & 0xFF); return static_cast< Int32 >((_Func->GetPlayerColour(m_ID) >> 16u) & 0xFFu);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -2033,7 +2023,7 @@ Int32 CPlayer::GetColorG() const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return static_cast< Int32 >((_Func->GetPlayerColour(m_ID) >> 8) & 0xFF); return static_cast< Int32 >((_Func->GetPlayerColour(m_ID) >> 8u) & 0xFFu);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -2042,7 +2032,7 @@ Int32 CPlayer::GetColorB() const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return static_cast< Int32 >(_Func->GetPlayerColour(m_ID) & 0xFF); return static_cast< Int32 >(_Func->GetPlayerColour(m_ID) & 0xFFu);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -2051,8 +2041,8 @@ void CPlayer::SetColorR(Int32 r) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetPlayerColour(m_ID, (ConvTo< Uint8 >::From(r) << 16) | _Func->SetPlayerColour(m_ID, (ConvTo< Uint8 >::From(r) << 16u) | // NOLINT(hicpp-signed-bitwise)
(~(0xFF << 16) & _Func->GetPlayerColour(m_ID))); (~(0xFFu << 16u) & _Func->GetPlayerColour(m_ID)));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -2061,8 +2051,8 @@ void CPlayer::SetColorG(Int32 g) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetPlayerColour(m_ID, (ConvTo< Uint8 >::From(g) << 8) | _Func->SetPlayerColour(m_ID, (ConvTo< Uint8 >::From(g) << 8u) | // NOLINT(hicpp-signed-bitwise)
(~(0xFF << 8) & _Func->GetPlayerColour(m_ID))); (~(0xFFu << 8u) & _Func->GetPlayerColour(m_ID)));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -2072,14 +2062,14 @@ void CPlayer::SetColorB(Int32 g) const
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetPlayerColour(m_ID, (ConvTo< Uint8 >::From(g)) | _Func->SetPlayerColour(m_ID, (ConvTo< Uint8 >::From(g)) |
(~(0xFF) & _Func->GetPlayerColour(m_ID))); (~(0xFFu) & _Func->GetPlayerColour(m_ID)));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
SQInteger CPlayer::Msg(HSQUIRRELVM vm) SQInteger CPlayer::Msg(HSQUIRRELVM vm)
{ {
// The function needs at least 2 arguments // The function needs at least 2 arguments
const Int32 top = sq_gettop(vm); const auto top = sq_gettop(vm);
// Was the message color specified? // Was the message color specified?
if (top <= 1) if (top <= 1)
{ {
@ -2154,7 +2144,7 @@ SQInteger CPlayer::Msg(HSQUIRRELVM vm)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
SQInteger CPlayer::MsgP(HSQUIRRELVM vm) SQInteger CPlayer::MsgP(HSQUIRRELVM vm)
{ {
const Int32 top = sq_gettop(vm); const auto top = sq_gettop(vm);
// Was the index of the message prefix specified? // Was the index of the message prefix specified?
if (top <= 1) if (top <= 1)
{ {
@ -2216,7 +2206,7 @@ SQInteger CPlayer::MsgP(HSQUIRRELVM vm)
return val.mRes; // Propagate the error! return val.mRes; // Propagate the error!
} }
vcmpError result = vcmpErrorNone; vcmpError result;
// Send the resulted message string // Send the resulted message string
if (player->mLimitPrefixPostfixMessage) if (player->mLimitPrefixPostfixMessage)
{ {
@ -2243,7 +2233,7 @@ SQInteger CPlayer::MsgP(HSQUIRRELVM vm)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
SQInteger CPlayer::MsgEx(HSQUIRRELVM vm) SQInteger CPlayer::MsgEx(HSQUIRRELVM vm)
{ {
const Int32 top = sq_gettop(vm); const auto top = sq_gettop(vm);
// Was the index of the message prefix specified? // Was the index of the message prefix specified?
if (top <= 1) if (top <= 1)
{ {
@ -2322,7 +2312,7 @@ SQInteger CPlayer::MsgEx(HSQUIRRELVM vm)
return val.mRes; // Propagate the error! return val.mRes; // Propagate the error!
} }
vcmpError result = vcmpErrorNone; vcmpError result;
// Send the resulted message string // Send the resulted message string
if (player->mLimitPrefixPostfixMessage) if (player->mLimitPrefixPostfixMessage)
{ {
@ -2349,7 +2339,7 @@ SQInteger CPlayer::MsgEx(HSQUIRRELVM vm)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
SQInteger CPlayer::Message(HSQUIRRELVM vm) SQInteger CPlayer::Message(HSQUIRRELVM vm)
{ {
const Int32 top = sq_gettop(vm); const auto top = sq_gettop(vm);
// Was the message value specified? // Was the message value specified?
if (top <= 1) if (top <= 1)
{ {
@ -2406,7 +2396,7 @@ SQInteger CPlayer::Message(HSQUIRRELVM vm)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
SQInteger CPlayer::Announce(HSQUIRRELVM vm) SQInteger CPlayer::Announce(HSQUIRRELVM vm)
{ {
const Int32 top = sq_gettop(vm); const auto top = sq_gettop(vm);
// Was the announcement value specified? // Was the announcement value specified?
if (top <= 1) if (top <= 1)
{ {
@ -2468,7 +2458,7 @@ SQInteger CPlayer::Announce(HSQUIRRELVM vm)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
SQInteger CPlayer::AnnounceEx(HSQUIRRELVM vm) SQInteger CPlayer::AnnounceEx(HSQUIRRELVM vm)
{ {
const Int32 top = sq_gettop(vm); const auto top = sq_gettop(vm);
// Was the announcement style specified? // Was the announcement style specified?
if (top <= 1) if (top <= 1)
{ {
@ -2522,7 +2512,6 @@ SQInteger CPlayer::AnnounceEx(HSQUIRRELVM vm)
// Validate the result // Validate the result
if (result == vcmpErrorArgumentOutOfBounds) if (result == vcmpErrorArgumentOutOfBounds)
{ {
return sq_throwerror(vm, "");
return sq_throwerror(vm, ToStrF("Invalid announcement style %d [%s]", return sq_throwerror(vm, ToStrF("Invalid announcement style %d [%s]",
style, player->GetTag().c_str())); style, player->GetTag().c_str()));
} }
@ -2563,7 +2552,7 @@ SQInteger Player_FindAuto(HSQUIRRELVM vm)
// Finally, attempt to push the return value // Finally, attempt to push the return value
else else
{ {
sq_pushobject(vm, Core::Get().GetPlayer(id).mObj.mObj); sq_pushobject(vm, Core::Get().GetPlayer(static_cast< Int32 >(id)).mObj.mObj);
} }
} break; } break;
case OT_FLOAT: { case OT_FLOAT: {
@ -2577,7 +2566,7 @@ SQInteger Player_FindAuto(HSQUIRRELVM vm)
return res; // Propagate the error return res; // Propagate the error
} }
// Convert the float value to an integer // Convert the float value to an integer
const Int32 id = std::round(static_cast< Float32 >(fid)); const auto id = static_cast< Int32 >(std::lround(static_cast< Float32 >(fid)));
// Check identifier range // Check identifier range
if (INVALID_ENTITYEX(id, SQMOD_PLAYER_POOL)) if (INVALID_ENTITYEX(id, SQMOD_PLAYER_POOL))
{ {
@ -2644,7 +2633,7 @@ SQInteger Player_ExistsAuto(HSQUIRRELVM vm)
return res; // Propagate the error return res; // Propagate the error
} }
// Check identifier range and the entity instance // Check identifier range and the entity instance
else if (INVALID_ENTITYEX(id, SQMOD_PLAYER_POOL) || INVALID_ENTITY(Core::Get().GetPlayer(id).mID)) else if (INVALID_ENTITYEX(id, SQMOD_PLAYER_POOL) || INVALID_ENTITY(Core::Get().GetPlayer(static_cast< Int32 >(id)).mID))
{ {
sq_pushbool(vm, SQFalse); sq_pushbool(vm, SQFalse);
} }
@ -2664,7 +2653,7 @@ SQInteger Player_ExistsAuto(HSQUIRRELVM vm)
return res; // Propagate the error return res; // Propagate the error
} }
// Convert the float value to an integer // Convert the float value to an integer
const Int32 id = std::round(static_cast< Float32 >(fid)); const auto id = static_cast< Int32 >(std::lround(static_cast< Float32 >(fid)));
// Check identifier range and the entity instance // Check identifier range and the entity instance
if (INVALID_ENTITYEX(id, SQMOD_PLAYER_POOL) || INVALID_ENTITY(Core::Get().GetPlayer(id).mID)) if (INVALID_ENTITYEX(id, SQMOD_PLAYER_POOL) || INVALID_ENTITY(Core::Get().GetPlayer(id).mID))
{ {

29
module/Entity/Player.hpp
View File

@ -12,16 +12,16 @@ namespace SqMod {
*/ */
enum PlayerCircularLocks enum PlayerCircularLocks
{ {
PLAYERCL_EMIT_PLAYER_OPTION = (1 << 0), PLAYERCL_EMIT_PLAYER_OPTION = (1u << 0u),
PLAYERCL_EMIT_PLAYER_ADMIN = (1 << 1), PLAYERCL_EMIT_PLAYER_ADMIN = (1u << 1u),
PLAYERCL_EMIT_PLAYER_WORLD = (1 << 2), PLAYERCL_EMIT_PLAYER_WORLD = (1u << 2u),
PLAYERCL_EMIT_PLAYER_TEAM = (1 << 3), PLAYERCL_EMIT_PLAYER_TEAM = (1u << 3u),
PLAYERCL_EMIT_PLAYER_SKIN = (1 << 4), PLAYERCL_EMIT_PLAYER_SKIN = (1u << 4u),
PLAYERCL_EMIT_PLAYER_MONEY = (1 << 5), PLAYERCL_EMIT_PLAYER_MONEY = (1u << 5u),
PLAYERCL_EMIT_PLAYER_SCORE = (1 << 6), PLAYERCL_EMIT_PLAYER_SCORE = (1u << 6u),
PLAYERCL_EMIT_PLAYER_WANTED_LEVEL = (1 << 7), PLAYERCL_EMIT_PLAYER_WANTED_LEVEL = (1u << 7u),
PLAYERCL_EMIT_PLAYER_IMMUNITY = (1 << 8), PLAYERCL_EMIT_PLAYER_IMMUNITY = (1u << 8u),
PLAYERCL_EMIT_PLAYER_ALPHA = (1 << 9) PLAYERCL_EMIT_PLAYER_ALPHA = (1u << 9u)
}; };
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
@ -65,7 +65,7 @@ private:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Base constructor. * Base constructor.
*/ */
CPlayer(Int32 id); explicit CPlayer(Int32 id);
public: public:
@ -137,11 +137,6 @@ public:
*/ */
CPlayer(CPlayer &&) = delete; CPlayer(CPlayer &&) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CPlayer();
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled) * Copy assignment operator. (disabled)
*/ */
@ -467,7 +462,7 @@ public:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Retrieve the frames per second of the managed player entity. * Retrieve the frames per second of the managed player entity.
*/ */
Float32 GetFPS() const; SQFloat GetFPS() const;
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Retrieve the current health of the managed player entity. * Retrieve the current health of the managed player entity.

176
module/Entity/Vehicle.cpp
View File

@ -38,12 +38,6 @@ CVehicle::CVehicle(Int32 id)
/* ... */ /* ... */
} }
// ------------------------------------------------------------------------------------------------
CVehicle::~CVehicle()
{
/* ... */
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const String & CVehicle::ToString() const const String & CVehicle::ToString() const
{ {
@ -61,7 +55,7 @@ void CVehicle::SetTag(StackStrF & tag)
{ {
if (tag.mLen > 0) if (tag.mLen > 0)
{ {
m_Tag.assign(tag.mPtr, tag.mLen); m_Tag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
} }
else else
{ {
@ -156,7 +150,7 @@ void CVehicle::SetOption(Int32 option_id, bool toggle)
const bool value = _Func->GetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id)); const bool value = _Func->GetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id));
// Attempt to modify the current value of the specified option // Attempt to modify the current value of the specified option
if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id), if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id),
toggle) == vcmpErrorArgumentOutOfBounds) static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
{ {
STHROWF("Invalid option identifier: %d", option_id); STHROWF("Invalid option identifier: %d", option_id);
} }
@ -176,7 +170,7 @@ void CVehicle::SetOptionEx(Int32 option_id, bool toggle, Int32 header, LightObj
const bool value = _Func->GetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id)); const bool value = _Func->GetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id));
// Attempt to modify the current value of the specified option // Attempt to modify the current value of the specified option
if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id), if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id),
toggle) == vcmpErrorArgumentOutOfBounds) static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
{ {
STHROWF("Invalid option identifier: %d", option_id); STHROWF("Invalid option identifier: %d", option_id);
} }
@ -328,7 +322,7 @@ void CVehicle::SetImmunity(Int32 flags)
// Grab the current value for this property // Grab the current value for this property
const Int32 current = _Func->GetVehicleImmunityFlags(m_ID); const Int32 current = _Func->GetVehicleImmunityFlags(m_ID);
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetVehicleImmunityFlags(m_ID, flags); _Func->SetVehicleImmunityFlags(m_ID, static_cast< uint32_t >(flags));
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_IMMUNITY)) if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_IMMUNITY))
{ {
@ -376,7 +370,7 @@ void CVehicle::SetPosition(const Vector3 & pos) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehiclePosition(m_ID, pos.x, pos.y, pos.z, false); _Func->SetVehiclePosition(m_ID, pos.x, pos.y, pos.z, static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -385,7 +379,7 @@ void CVehicle::SetPositionEx(const Vector3 & pos, bool empty) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehiclePosition(m_ID, pos.x, pos.y, pos.z, empty); _Func->SetVehiclePosition(m_ID, pos.x, pos.y, pos.z, static_cast< uint8_t >(empty));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -394,7 +388,7 @@ void CVehicle::SetPositionEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehiclePosition(m_ID, x, y, z, false); _Func->SetVehiclePosition(m_ID, x, y, z, static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -403,7 +397,7 @@ void CVehicle::SetPositionEx(Float32 x, Float32 y, Float32 z, bool empty) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehiclePosition(m_ID, x, y, z, empty); _Func->SetVehiclePosition(m_ID, x, y, z, static_cast< uint8_t >(empty));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -476,7 +470,7 @@ Vector3 CVehicle::GetSpeed() const
// Create a default vector instance // Create a default vector instance
Vector3 vec; Vector3 vec;
// Query the server for the values // Query the server for the values
_Func->GetVehicleSpeed(m_ID, &vec.x, &vec.y, &vec.z, false); _Func->GetVehicleSpeed(m_ID, &vec.x, &vec.y, &vec.z, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return vec; return vec;
} }
@ -487,7 +481,8 @@ void CVehicle::SetSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z, false, false); _Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -496,7 +491,7 @@ void CVehicle::SetSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, false, false); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -505,7 +500,8 @@ void CVehicle::AddSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z, true, false); _Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(true), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -514,7 +510,7 @@ void CVehicle::AddSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, true, false); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(true), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -525,7 +521,7 @@ Vector3 CVehicle::GetRelativeSpeed() const
// Create a default vector instance // Create a default vector instance
Vector3 vec; Vector3 vec;
// Query the server for the values // Query the server for the values
_Func->GetVehicleSpeed(m_ID, &vec.x, &vec.y, &vec.z, true); _Func->GetVehicleSpeed(m_ID, &vec.x, &vec.y, &vec.z, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return vec; return vec;
} }
@ -536,7 +532,8 @@ void CVehicle::SetRelativeSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z, false, true); _Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -545,7 +542,7 @@ void CVehicle::SetRelativeSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, false, true); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -554,7 +551,8 @@ void CVehicle::AddRelativeSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z, true, true); _Func->SetVehicleSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(true), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -563,7 +561,7 @@ void CVehicle::AddRelativeSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, true, true); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(true), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -574,7 +572,7 @@ Vector3 CVehicle::GetTurnSpeed() const
// Create a default vector instance // Create a default vector instance
Vector3 vec; Vector3 vec;
// Query the server for the values // Query the server for the values
_Func->GetVehicleTurnSpeed(m_ID, &vec.x, &vec.y, &vec.z, false); _Func->GetVehicleTurnSpeed(m_ID, &vec.x, &vec.y, &vec.z, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return vec; return vec;
} }
@ -585,7 +583,8 @@ void CVehicle::SetTurnSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z, false, false); _Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -594,7 +593,8 @@ void CVehicle::SetTurnSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, false, false); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(false),
static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -603,7 +603,8 @@ void CVehicle::AddTurnSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z, true, false); _Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(true), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -612,7 +613,8 @@ void CVehicle::AddTurnSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, true, false); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(true),
static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -623,7 +625,7 @@ Vector3 CVehicle::GetRelativeTurnSpeed() const
// Create a default vector instance // Create a default vector instance
Vector3 vec; Vector3 vec;
// Query the server for the values // Query the server for the values
_Func->GetVehicleTurnSpeed(m_ID, &vec.x, &vec.y, &vec.z, true); _Func->GetVehicleTurnSpeed(m_ID, &vec.x, &vec.y, &vec.z, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return vec; return vec;
} }
@ -634,7 +636,8 @@ void CVehicle::SetRelativeTurnSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z, false, true); _Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -643,7 +646,8 @@ void CVehicle::SetRelativeTurnSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, false, true); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(false),
static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -652,7 +656,8 @@ void CVehicle::AddRelativeTurnSpeed(const Vector3 & vel) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z, true, true); _Func->SetVehicleTurnSpeed(m_ID, vel.x, vel.y, vel.z,
static_cast< uint8_t >(true), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -661,7 +666,8 @@ void CVehicle::AddRelativeTurnSpeedEx(Float32 x, Float32 y, Float32 z) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, true, true); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(true),
static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1045,12 +1051,12 @@ bool CVehicle::ExistsHandlingRule(Int32 rule) const
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
Float32 CVehicle::GetHandlingRule(Int32 rule) const SQFloat CVehicle::GetHandlingRule(Int32 rule) const
{ {
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return _Func->GetInstHandlingRule(m_ID, rule); return static_cast< SQFloat >(_Func->GetInstHandlingRule(m_ID, rule));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1059,7 +1065,7 @@ void CVehicle::SetHandlingRule(Int32 rule, Float32 data)
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Grab the current value for this property // Grab the current value for this property
const Float32 current = _Func->GetInstHandlingRule(m_ID, rule); const auto current = static_cast< SQFloat >(_Func->GetInstHandlingRule(m_ID, rule));
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->SetInstHandlingRule(m_ID, rule, data); _Func->SetInstHandlingRule(m_ID, rule, data);
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
@ -1078,7 +1084,7 @@ void CVehicle::ResetHandlingRule(Int32 rule)
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Grab the current value for this property // Grab the current value for this property
const Float32 current = _Func->GetInstHandlingRule(m_ID, rule); const auto current = static_cast< SQFloat >(_Func->GetInstHandlingRule(m_ID, rule));
// Avoid property unwind from a recursive call // Avoid property unwind from a recursive call
_Func->ResetInstHandlingRule(m_ID, rule); _Func->ResetInstHandlingRule(m_ID, rule);
// Avoid infinite recursive event loops // Avoid infinite recursive event loops
@ -1087,7 +1093,7 @@ void CVehicle::ResetHandlingRule(Int32 rule)
// Prevent this event from triggering while executed // Prevent this event from triggering while executed
BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_HANDLINGRULE); BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_HANDLINGRULE);
// Now forward the event call // Now forward the event call
Core::Get().EmitVehicleHandlingRule(m_ID, rule, current, _Func->GetInstHandlingRule(m_ID, rule)); Core::Get().EmitVehicleHandlingRule(m_ID, rule, current, static_cast< SQFloat >(_Func->GetInstHandlingRule(m_ID, rule)));
} }
} }
@ -1115,7 +1121,7 @@ void CVehicle::SetLightsData(Int32 data) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Apply the requested data // Apply the requested data
_Func->SetVehicleLightsData(m_ID, data); _Func->SetVehicleLightsData(m_ID, static_cast< uint32_t >(data));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1129,7 +1135,8 @@ bool CVehicle::Embark(CPlayer & player) const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
return (_Func->PutPlayerInVehicle(player.GetID(), m_ID, 0, true, true) return (_Func->PutPlayerInVehicle(player.GetID(), m_ID, 0,
static_cast< uint8_t >(true), static_cast< uint8_t >(true))
!= vcmpErrorRequestDenied); != vcmpErrorRequestDenied);
} }
@ -1144,8 +1151,8 @@ bool CVehicle::Embark(CPlayer & player, Int32 slot, bool allocate, bool warp) co
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Perform the requested operation // Perform the requested operation
return (_Func->PutPlayerInVehicle(player.GetID(), m_ID, slot, allocate, warp) return (_Func->PutPlayerInVehicle(player.GetID(), m_ID, slot,
!= vcmpErrorRequestDenied); static_cast< uint8_t >(allocate), static_cast< uint8_t >(warp)) != vcmpErrorRequestDenied);
} }
#if SQMOD_SDK_LEAST(2, 1) #if SQMOD_SDK_LEAST(2, 1)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1190,7 +1197,7 @@ bool CVehicle::GetCollideAreas() const
// Validate the managed identifier // Validate the managed identifier
Validate(); Validate();
// Return the requested information // Return the requested information
return (Core::Get().GetVehicle(m_ID).mFlags & ENF_AREA_TRACK); return static_cast< bool >(Core::Get().GetVehicle(m_ID).mFlags & ENF_AREA_TRACK);
} }
void CVehicle::SetCollideAreas(bool toggle) const void CVehicle::SetCollideAreas(bool toggle) const
@ -1391,7 +1398,7 @@ void CVehicle::SetPositionX(Float32 x) const
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehiclePosition(m_ID, &dummy, &y, &z); _Func->GetVehiclePosition(m_ID, &dummy, &y, &z);
// Perform the requested operation // Perform the requested operation
_Func->SetVehiclePosition(m_ID, x, y, z, false); _Func->SetVehiclePosition(m_ID, x, y, z, static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1404,7 +1411,7 @@ void CVehicle::SetPositionY(Float32 y) const
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehiclePosition(m_ID, &x, &dummy, &z); _Func->GetVehiclePosition(m_ID, &x, &dummy, &z);
// Perform the requested operation // Perform the requested operation
_Func->SetVehiclePosition(m_ID, x, y, z, false); _Func->SetVehiclePosition(m_ID, x, y, z, static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1417,7 +1424,7 @@ void CVehicle::SetPositionZ(Float32 z) const
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehiclePosition(m_ID, &x, &y, &dummy); _Func->GetVehiclePosition(m_ID, &x, &y, &dummy);
// Perform the requested operation // Perform the requested operation
_Func->SetVehiclePosition(m_ID, z, y, z, false); _Func->SetVehiclePosition(m_ID, z, y, z, static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1611,7 +1618,7 @@ Float32 CVehicle::GetSpeedX() const
// Clear previous information, if any // Clear previous information, if any
Float32 x = 0.0f, dummy; Float32 x = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleSpeed(m_ID, &x, &dummy, &dummy, false); _Func->GetVehicleSpeed(m_ID, &x, &dummy, &dummy, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return x; return x;
} }
@ -1624,7 +1631,7 @@ Float32 CVehicle::GetSpeedY() const
// Clear previous information, if any // Clear previous information, if any
Float32 y = 0.0f, dummy; Float32 y = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleSpeed(m_ID, &dummy, &y, &dummy, false); _Func->GetVehicleSpeed(m_ID, &dummy, &y, &dummy, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return y; return y;
} }
@ -1637,7 +1644,7 @@ Float32 CVehicle::GetSpeedZ() const
// Clear previous information, if any // Clear previous information, if any
Float32 z = 0.0f, dummy; Float32 z = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleSpeed(m_ID, &dummy, &dummy, &z, false); _Func->GetVehicleSpeed(m_ID, &dummy, &dummy, &z, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return z; return z;
} }
@ -1650,9 +1657,9 @@ void CVehicle::SetSpeedX(Float32 x) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 y, z, dummy; Float32 y, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleSpeed(m_ID, &dummy, &y, &z, false); _Func->GetVehicleSpeed(m_ID, &dummy, &y, &z, static_cast< uint8_t >(false));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, false, false); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1663,9 +1670,9 @@ void CVehicle::SetSpeedY(Float32 y) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, z, dummy; Float32 x, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleSpeed(m_ID, &x, &dummy, &z, false); _Func->GetVehicleSpeed(m_ID, &x, &dummy, &z, static_cast< uint8_t >(false));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, false, false); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1676,9 +1683,9 @@ void CVehicle::SetSpeedZ(Float32 z) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, y, dummy; Float32 x, y, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleSpeed(m_ID, &x, &y, &dummy, false); _Func->GetVehicleSpeed(m_ID, &x, &y, &dummy, static_cast< uint8_t >(false));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, z, y, z, false, false); _Func->SetVehicleSpeed(m_ID, z, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1689,7 +1696,7 @@ Float32 CVehicle::GetRelativeSpeedX() const
// Clear previous information, if any // Clear previous information, if any
Float32 x = 0.0f, dummy; Float32 x = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleSpeed(m_ID, &x, &dummy, &dummy, true); _Func->GetVehicleSpeed(m_ID, &x, &dummy, &dummy, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return x; return x;
} }
@ -1702,7 +1709,7 @@ Float32 CVehicle::GetRelativeSpeedY() const
// Clear previous information, if any // Clear previous information, if any
Float32 y = 0.0f, dummy; Float32 y = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleSpeed(m_ID, &dummy, &y, &dummy, true); _Func->GetVehicleSpeed(m_ID, &dummy, &y, &dummy, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return y; return y;
} }
@ -1715,7 +1722,7 @@ Float32 CVehicle::GetRelativeSpeedZ() const
// Clear previous information, if any // Clear previous information, if any
Float32 z = 0.0f, dummy; Float32 z = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleSpeed(m_ID, &dummy, &dummy, &z, true); _Func->GetVehicleSpeed(m_ID, &dummy, &dummy, &z, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return z; return z;
} }
@ -1728,9 +1735,9 @@ void CVehicle::SetRelativeSpeedX(Float32 x) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 y, z, dummy; Float32 y, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleSpeed(m_ID, &dummy, &y, &z, true); _Func->GetVehicleSpeed(m_ID, &dummy, &y, &z, static_cast< uint8_t >(true));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, false, true); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1741,9 +1748,9 @@ void CVehicle::SetRelativeSpeedY(Float32 y) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, z, dummy; Float32 x, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleSpeed(m_ID, &x, &dummy, &z, true); _Func->GetVehicleSpeed(m_ID, &x, &dummy, &z, static_cast< uint8_t >(true));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, x, y, z, false, true); _Func->SetVehicleSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1754,9 +1761,9 @@ void CVehicle::SetRelativeSpeedZ(Float32 z) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, y, dummy; Float32 x, y, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleSpeed(m_ID, &x, &y, &dummy, true); _Func->GetVehicleSpeed(m_ID, &x, &y, &dummy, static_cast< uint8_t >(true));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleSpeed(m_ID, z, y, z, false, true); _Func->SetVehicleSpeed(m_ID, z, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1767,7 +1774,7 @@ Float32 CVehicle::GetTurnSpeedX() const
// Clear previous information, if any // Clear previous information, if any
Float32 x = 0.0f, dummy; Float32 x = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &dummy, false); _Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &dummy, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return x; return x;
} }
@ -1780,7 +1787,7 @@ Float32 CVehicle::GetTurnSpeedY() const
// Clear previous information, if any // Clear previous information, if any
Float32 y = 0.0f, dummy; Float32 y = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &dummy, false); _Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &dummy, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return y; return y;
} }
@ -1793,7 +1800,7 @@ Float32 CVehicle::GetTurnSpeedZ() const
// Clear previous information, if any // Clear previous information, if any
Float32 z = 0.0f, dummy; Float32 z = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleTurnSpeed(m_ID, &dummy, &dummy, &z, false); _Func->GetVehicleTurnSpeed(m_ID, &dummy, &dummy, &z, static_cast< uint8_t >(false));
// Return the requested information // Return the requested information
return z; return z;
} }
@ -1806,9 +1813,9 @@ void CVehicle::SetTurnSpeedX(Float32 x) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 y, z, dummy; Float32 y, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &z, false); _Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &z, static_cast< uint8_t >(false));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, false, false); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1819,9 +1826,9 @@ void CVehicle::SetTurnSpeedY(Float32 y) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, z, dummy; Float32 x, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &z, false); _Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &z, static_cast< uint8_t >(false));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, false, false); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1832,9 +1839,9 @@ void CVehicle::SetTurnSpeedZ(Float32 z) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, y, dummy; Float32 x, y, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleTurnSpeed(m_ID, &x, &y, &dummy, false); _Func->GetVehicleTurnSpeed(m_ID, &x, &y, &dummy, static_cast< uint8_t >(false));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, z, y, z, false, false); _Func->SetVehicleTurnSpeed(m_ID, z, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(false));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1845,7 +1852,7 @@ Float32 CVehicle::GetRelativeTurnSpeedX() const
// Clear previous information, if any // Clear previous information, if any
Float32 x = 0.0f, dummy; Float32 x = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &dummy, true); _Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &dummy, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return x; return x;
} }
@ -1858,7 +1865,7 @@ Float32 CVehicle::GetRelativeTurnSpeedY() const
// Clear previous information, if any // Clear previous information, if any
Float32 y = 0.0f, dummy; Float32 y = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &dummy, true); _Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &dummy, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return y; return y;
} }
@ -1871,7 +1878,7 @@ Float32 CVehicle::GetRelativeTurnSpeedZ() const
// Clear previous information, if any // Clear previous information, if any
Float32 z = 0.0f, dummy; Float32 z = 0.0f, dummy;
// Query the server for the requested component value // Query the server for the requested component value
_Func->GetVehicleTurnSpeed(m_ID, &dummy, &dummy, &z, true); _Func->GetVehicleTurnSpeed(m_ID, &dummy, &dummy, &z, static_cast< uint8_t >(true));
// Return the requested information // Return the requested information
return z; return z;
} }
@ -1884,9 +1891,9 @@ void CVehicle::SetRelativeTurnSpeedX(Float32 x) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 y, z, dummy; Float32 y, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &z, true); _Func->GetVehicleTurnSpeed(m_ID, &dummy, &y, &z, static_cast< uint8_t >(true));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, false, true); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1897,9 +1904,9 @@ void CVehicle::SetRelativeTurnSpeedY(Float32 y) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, z, dummy; Float32 x, z, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &z, true); _Func->GetVehicleTurnSpeed(m_ID, &x, &dummy, &z, static_cast< uint8_t >(true));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, x, y, z, false, true); _Func->SetVehicleTurnSpeed(m_ID, x, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1910,9 +1917,9 @@ void CVehicle::SetRelativeTurnSpeedZ(Float32 z) const
// Reserve some temporary floats to retrieve the missing components // Reserve some temporary floats to retrieve the missing components
Float32 x, y, dummy; Float32 x, y, dummy;
// Retrieve the current values for unchanged components // Retrieve the current values for unchanged components
_Func->GetVehicleTurnSpeed(m_ID, &x, &y, &dummy, true); _Func->GetVehicleTurnSpeed(m_ID, &x, &y, &dummy, static_cast< uint8_t >(true));
// Perform the requested operation // Perform the requested operation
_Func->SetVehicleTurnSpeed(m_ID, z, y, z, false, true); _Func->SetVehicleTurnSpeed(m_ID, z, y, z, static_cast< uint8_t >(false), static_cast< uint8_t >(true));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -1946,7 +1953,10 @@ static LightObj & Vehicle_Create(Int32 model, Int32 world, const Vector3 & pos,
} }
// ================================================================================================ // ================================================================================================
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void Register_CVehicle(HSQUIRRELVM vm) void Register_CVehicle(HSQUIRRELVM vm)
#pragma clang diagnostic pop
{ {
RootTable(vm).Bind(Typename::Str, RootTable(vm).Bind(Typename::Str,
Class< CVehicle, NoConstructor< CVehicle > >(vm, Typename::Str) Class< CVehicle, NoConstructor< CVehicle > >(vm, Typename::Str)

25
module/Entity/Vehicle.hpp
View File

@ -11,14 +11,14 @@ namespace SqMod {
*/ */
enum VehicleCircularLocks enum VehicleCircularLocks
{ {
VEHICLECL_EMIT_VEHICLE_OPTION = (1 << 0), VEHICLECL_EMIT_VEHICLE_OPTION = (1u << 0u),
VEHICLECL_EMIT_VEHICLE_WORLD = (1 << 1), VEHICLECL_EMIT_VEHICLE_WORLD = (1u << 1u),
VEHICLECL_EMIT_VEHICLE_IMMUNITY = (1 << 2), VEHICLECL_EMIT_VEHICLE_IMMUNITY = (1u << 2u),
VEHICLECL_EMIT_VEHICLE_PARTSTATUS = (1 << 3), VEHICLECL_EMIT_VEHICLE_PARTSTATUS = (1u << 3u),
VEHICLECL_EMIT_VEHICLE_TYRESTATUS = (1 << 4), VEHICLECL_EMIT_VEHICLE_TYRESTATUS = (1u << 4u),
VEHICLECL_EMIT_VEHICLE_DAMAGEDATA = (1 << 5), VEHICLECL_EMIT_VEHICLE_DAMAGEDATA = (1u << 5u),
VEHICLECL_EMIT_VEHICLE_RADIO = (1 << 6), VEHICLECL_EMIT_VEHICLE_RADIO = (1u << 6u),
VEHICLECL_EMIT_VEHICLE_HANDLINGRULE = (1 << 7) VEHICLECL_EMIT_VEHICLE_HANDLINGRULE = (1u << 7u)
}; };
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
@ -54,7 +54,7 @@ private:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Base constructor. * Base constructor.
*/ */
CVehicle(Int32 id); explicit CVehicle(Int32 id);
public: public:
@ -73,11 +73,6 @@ public:
*/ */
CVehicle(CVehicle &&) = delete; CVehicle(CVehicle &&) = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CVehicle();
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Copy assignment operator. (disabled) * Copy assignment operator. (disabled)
*/ */
@ -584,7 +579,7 @@ public:
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Retrieve the handling data of the managed vehicle entity. * Retrieve the handling data of the managed vehicle entity.
*/ */
Float32 GetHandlingRule(Int32 rule) const; SQFloat GetHandlingRule(Int32 rule) const;
/* -------------------------------------------------------------------------------------------- /* --------------------------------------------------------------------------------------------
* Modify the handling data of the managed vehicle entity. * Modify the handling data of the managed vehicle entity.