3418 lines
128 KiB
C++
3418 lines
128 KiB
C++
//
|
|
// filename: commands_weapon.cpp
|
|
// description:
|
|
//
|
|
|
|
// --- Include Files ------------------------------------------------------------
|
|
|
|
// C headers
|
|
// Rage headers
|
|
#include "script/wrapper.h"
|
|
// Game headers
|
|
#include "audio/weaponaudioentity.h"
|
|
#include "Camera/CamInterface.h"
|
|
#include "Frontend/NewHud.h"
|
|
#include "Network/Events/NetworkEventTypes.h"
|
|
#include "Network/Objects/Entities/NetObjPlayer.h"
|
|
#include "Peds/Ped.h"
|
|
#include "Peds/PedIntelligence.h"
|
|
#include "pickups/Data/RewardData.h"
|
|
#include "Pickups/PickupManager.h"
|
|
#include "Script/Handlers/GameScriptResources.h"
|
|
#include "Script/Script.h"
|
|
#include "Script/Script_Helper.h"
|
|
#include "Task/Weapons/Gun/TaskAimGunOnFoot.h"
|
|
#include "Task/Weapons/Gun/TaskReloadGun.h"
|
|
#include "Task/Weapons/TaskDetonator.h"
|
|
#include "Vehicles/Vehicle.h"
|
|
#include "Vehicles/VehicleGadgets.h"
|
|
#include "VehicleAi/VehicleIntelligence.h"
|
|
#include "Weapons/Components/WeaponComponent.h"
|
|
#include "Weapons/Components/WeaponComponentManager.h"
|
|
#include "Weapons/Info/WeaponAnimationsManager.h"
|
|
#include "Weapons/Inventory/PedInventoryLoadOut.h"
|
|
#include "Weapons/Projectiles/ProjectileManager.h"
|
|
#include "Weapons/Projectiles/Projectile.h"
|
|
#include "Weapons/AirDefence.h"
|
|
#include "Weapons/WeaponManager.h"
|
|
#include "Weapons/Weapon.h"
|
|
#include "Weapons/WeaponDebug.h"
|
|
#include "Weapons/WeaponFactory.h"
|
|
#include "Weapons/WeaponScriptResource.h"
|
|
#include "Vehicles/Metadata/VehicleMetadataManager.h"
|
|
#include "Vehicles/Metadata/VehicleSeatInfo.h"
|
|
|
|
AI_OPTIMISATIONS()
|
|
AI_COVER_OPTIMISATIONS()
|
|
WEAPON_OPTIMISATIONS()
|
|
|
|
|
|
// --- Defines ------------------------------------------------------------------
|
|
|
|
// --- Constants ----------------------------------------------------------------
|
|
|
|
// --- Structure/Class Definitions ----------------------------------------------
|
|
// Keep in sync with definitions in commands_weapon.sch
|
|
struct scrWeaponHudValues
|
|
{
|
|
scrValue HudDamage;
|
|
scrValue HudSpeed;
|
|
scrValue HudCapacity;
|
|
scrValue HudAccuracy;
|
|
scrValue HudRange;
|
|
};
|
|
|
|
SCR_DEFINE_NEW_POINTER_PARAM_AND_RET(scrWeaponHudValues);
|
|
|
|
// --- Globals ------------------------------------------------------------------
|
|
|
|
// --- Static Globals -----------------------------------------------------------
|
|
|
|
// --- Static class members -----------------------------------------------------
|
|
|
|
// --- Code ---------------------------------------------------------------------
|
|
|
|
namespace weapon_commands {
|
|
void CommandEnableLaserSightRendering( bool bEnabled )
|
|
{
|
|
CWeaponManager::EnableLaserSightRendering( bEnabled );
|
|
}
|
|
|
|
//
|
|
// name: CommandGetWeaponComponentTypeModel
|
|
// description: Returns the hash key of the weapon model
|
|
int CommandGetWeaponComponentTypeModel(int weaponComponentHash)
|
|
{
|
|
if(SCRIPT_VERIFY( weaponComponentHash != 0, "GET_WEAPON_COMPONENT_TYPE_MODEL - Weapon component hash is invalid"))
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(weaponComponentHash);
|
|
if(scriptVerifyf(pComponentInfo, "Weapon component hash [%d] does not exist in data", weaponComponentHash))
|
|
{
|
|
if(CModelInfo::GetBaseModelInfoFromHashKey(pComponentInfo->GetModelHash(), NULL))
|
|
{
|
|
return pComponentInfo->GetModelHash();
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetWeaponTypeModel
|
|
// description: Returns the hash key of the weapon model
|
|
int CommandGetWeaponTypeModel(int weaponHash)
|
|
{
|
|
if(SCRIPT_VERIFY( weaponHash != 0, "GET_WEAPONTYPE_MODEL - Weapon hash is invalid"))
|
|
{
|
|
const CItemInfo* pItemInfo = CWeaponInfoManager::GetInfo(weaponHash);
|
|
if(scriptVerifyf(pItemInfo, "Weapon hash [%d] does not exist in data", weaponHash))
|
|
{
|
|
if(CModelInfo::GetBaseModelInfoFromHashKey(pItemInfo->GetModelHash(), NULL))
|
|
{
|
|
return pItemInfo->GetModelHash();
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetWeaponTypeSlot
|
|
// description: Return the weapon type slot HASH
|
|
int CommandGetWeaponTypeSlot(int weaponHash)
|
|
{
|
|
if(SCRIPT_VERIFY( weaponHash != 0, "GET_WEAPONTYPE_SLOT - Weapon hash is invalid"))
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(weaponHash);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPONTYPE_SLOT - Weapon hash [%d] does not exist in data", weaponHash))
|
|
{
|
|
return pWeaponInfo->GetSlot();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetWeaponTypeGroup
|
|
// description: Return the weapon type group HASH
|
|
int CommandGetWeaponTypeGroup(int weaponHash)
|
|
{
|
|
if(SCRIPT_VERIFY( weaponHash != 0, "GET_WEAPONTYPE_GROUP - Weapon hash is invalid"))
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(weaponHash);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPONTYPE_GROUP - Weapon hash [%d] does not exist in data", weaponHash))
|
|
{
|
|
return pWeaponInfo->GetGroup();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetWeaponComponentVariantExtraCount
|
|
// description: Returns the number of entries in the variant model info extra components array
|
|
int CommandGetWeaponComponentVariantExtraCount(int weaponComponentHash)
|
|
{
|
|
if(SCRIPT_VERIFY( weaponComponentHash != 0, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT - Weapon component hash is invalid"))
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(weaponComponentHash);
|
|
if(scriptVerifyf(pComponentInfo, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT - Weapon component hash [%d] does not exist in data", weaponComponentHash))
|
|
{
|
|
#if RSG_GEN9
|
|
if(scriptVerifyf(pComponentInfo->GetWeaponClassType() == WCT_VariantModel, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT - Weapon component hash [%d] is not of type WCT_VariantModel", weaponComponentHash))
|
|
#else
|
|
if(scriptVerifyf(pComponentInfo->GetClassId() == WCT_VariantModel, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT - Weapon component hash [%d] is not of type WCT_VariantModel", weaponComponentHash))
|
|
#endif
|
|
{
|
|
const CWeaponComponentVariantModelInfo *pComponentVariantModelInfo = static_cast<const CWeaponComponentVariantModelInfo*>(pComponentInfo);
|
|
if (pComponentVariantModelInfo)
|
|
{
|
|
return pComponentVariantModelInfo->GetExtraComponentCount();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetWeaponComponentVariantExtraModel
|
|
// description: Returns the model hash at the given index in the variant model info extra components array
|
|
int CommandGetWeaponComponentVariantExtraModel(int weaponComponentHash, int extraComponentIndex)
|
|
{
|
|
if(SCRIPT_VERIFY( weaponComponentHash != 0, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL - Weapon component hash is invalid"))
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(weaponComponentHash);
|
|
if(scriptVerifyf(pComponentInfo, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL - Weapon component hash [%d] does not exist in data", weaponComponentHash))
|
|
{
|
|
#if RSG_GEN9
|
|
if(scriptVerifyf(pComponentInfo->GetWeaponClassType() == WCT_VariantModel, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL - Weapon component hash [%d] is not of type WCT_VariantModel", weaponComponentHash))
|
|
#else
|
|
if(scriptVerifyf(pComponentInfo->GetClassId() == WCT_VariantModel, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL - Weapon component hash [%d] is not of type WCT_VariantModel", weaponComponentHash))
|
|
#endif
|
|
{
|
|
const CWeaponComponentVariantModelInfo *pComponentVariantModelInfo = static_cast<const CWeaponComponentVariantModelInfo*>(pComponentInfo);
|
|
if (pComponentVariantModelInfo)
|
|
{
|
|
s32 extraComponentCount = pComponentVariantModelInfo->GetExtraComponentCount();
|
|
if(scriptVerifyf(extraComponentIndex >= 0 && extraComponentIndex < extraComponentCount, "GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL - Array index of [%d] is invalid", extraComponentIndex))
|
|
{
|
|
u32 extraModelHash = pComponentVariantModelInfo->GetExtraComponentModelByIndex(extraComponentIndex);
|
|
if(CModelInfo::GetBaseModelInfoFromHashKey(extraModelHash, NULL))
|
|
{
|
|
return extraModelHash;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// name: CommandGiveWeaponToPed
|
|
// description: Give a weapon to a character with an amount of ammo
|
|
void CommandGiveWeaponToPed(int PedIndex, int TypeOfWeapon, int AmountOfAmmo, bool bForceIntoHand, bool bEquip)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
|
|
if(pPed)
|
|
{
|
|
//! Don't give dead melee peds weapons.
|
|
if(pPed->IsDeadByMelee())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (pPed->IsNetworkClone())
|
|
{
|
|
scriptAssertf(AmountOfAmmo < (1<<CGiveWeaponEvent::SIZEOF_AMMO), "%s:GIVE_WEAPON_TO_PED - Invalid ammo amount %d, max size is %d", CTheScripts::GetCurrentScriptNameAndProgramCounter(), AmountOfAmmo, (1<<CGiveWeaponEvent::SIZEOF_AMMO));
|
|
|
|
CGiveWeaponEvent::Trigger(pPed, TypeOfWeapon, AmountOfAmmo);
|
|
return;
|
|
}
|
|
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GIVE_WEAPON_TO_PED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if(scriptVerifyf(TypeOfWeapon != 0, "%s:GIVE_WEAPON_TO_PED - invalid TypeOfWeapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory()->AddWeaponAndAmmo(TypeOfWeapon, AmountOfAmmo), "%s:GIVE_WEAPON_TO_PED - Failed to give weapon [%d] to ped, is this a DLC weapon or invalid?", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:GIVE_WEAPON_TO_PED: [%d][%s], Ammo:%d: Ped 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon, atHashString(TypeOfWeapon).TryGetCStr(), AmountOfAmmo, pPed, pPed->GetDebugName(), PedIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
|
|
if(bEquip)
|
|
{
|
|
if(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ))
|
|
{
|
|
// Ensure current weapon is stored as a backup so we can restore it when getting out
|
|
pPed->GetWeaponManager()->SetBackupWeapon(TypeOfWeapon);
|
|
pPed->GetWeaponManager()->EquipBestWeapon();
|
|
}
|
|
else if(pPed->GetIsSwimming() || pPed->GetPedResetFlag(CPED_RESET_FLAG_IsClimbing))
|
|
{
|
|
// Ensure current weapon is stored as a backup so we can restore it when getting out
|
|
pPed->GetWeaponManager()->SetBackupWeapon(TypeOfWeapon);
|
|
}
|
|
else
|
|
{
|
|
pPed->GetWeaponManager()->EquipWeapon(TypeOfWeapon, -1, bForceIntoHand && !pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandGiveDelayedWeaponToPed(int PedIndex, int TypeOfWeapon, int AmountOfAmmo, bool bSetAsCurrentWeapon)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
|
|
if(pPed)
|
|
{
|
|
if (pPed->IsNetworkClone())
|
|
{ // just ignore bSetAsCurrentWeapon? Always treated as true.
|
|
scriptAssertf(AmountOfAmmo < (1<<CGiveWeaponEvent::SIZEOF_AMMO), "%s:GIVE_DELAYED_WEAPON_TO_PED - Invalid ammo amount %d, max size is %d", CTheScripts::GetCurrentScriptNameAndProgramCounter(), AmountOfAmmo, (1<<CGiveWeaponEvent::SIZEOF_AMMO));
|
|
CGiveWeaponEvent::Trigger(pPed, TypeOfWeapon, AmountOfAmmo);
|
|
return;
|
|
}
|
|
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:GIVE_DELAYED_WEAPON_TO_PED - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetInventory()->AddWeaponAndAmmo(TypeOfWeapon, AmountOfAmmo);
|
|
if(bSetAsCurrentWeapon)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GIVE_DELAYED_WEAPON_TO_PED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetWeaponManager()->EquipWeapon(TypeOfWeapon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandAddAmmoToPed
|
|
// description: Give ammo to character
|
|
void CommandAddAmmoToPed(int PedIndex, int TypeOfWeapon, int AmountOfAmmo)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:ADD_AMMO_TO_PED - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetInventory()->AddWeaponAmmo(TypeOfWeapon, AmountOfAmmo);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandSetPedAmmo
|
|
// description: Set ammo for a characters weapon
|
|
void CommandSetPedAmmo(int PedIndex, int TypeOfWeapon, int AmountOfAmmo, bool bIgnoreDeadCheck)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, bIgnoreDeadCheck ? CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES_NO_DEAD_CHECK : CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
|
|
|
|
if(pPed)
|
|
{
|
|
scriptAssertf(AmountOfAmmo < (1<<CGiveWeaponEvent::SIZEOF_AMMO), "%s:SET_PED_AMMO - Invalid ammo amount %d, max size is %d", CTheScripts::GetCurrentScriptNameAndProgramCounter(), AmountOfAmmo, (1<<CGiveWeaponEvent::SIZEOF_AMMO));
|
|
|
|
if (CTheScripts::Frack() && pPed->IsNetworkClone())
|
|
{
|
|
CGiveWeaponEvent::Trigger(pPed, TypeOfWeapon, AmountOfAmmo);
|
|
return;
|
|
}
|
|
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_AMMO - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetInventory()->SetWeaponAmmo(TypeOfWeapon, AmountOfAmmo);
|
|
|
|
// Update the current weapon ammo amount immediately for the UI system.
|
|
if(pPed->GetWeaponManager())
|
|
{
|
|
CWeapon* pWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
|
|
if(pWeapon && pWeapon->GetWeaponHash() == (u32)(TypeOfWeapon))
|
|
{
|
|
pWeapon->SetAmmoTotal(AmountOfAmmo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandSetPedInfiniteAmmo
|
|
// description: Enable/Disable infinite ammo for the specified ped
|
|
void CommandSetPedInfiniteAmmo(int PedIndex, bool bInfinite, int TypeOfWeapon)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_INFINITE_AMMO - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if(CTheScripts::Frack() && TypeOfWeapon == 0)
|
|
{
|
|
pPed->GetInventory()->GetAmmoRepository().SetUsingInfiniteAmmo(bInfinite);
|
|
}
|
|
else if(scriptVerifyf(pPed->GetInventory()->GetWeapon(TypeOfWeapon), "%s:SET_PED_INFINITE_AMMO - ped does not have weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pPed->GetInventory()->SetWeaponUsingInfiniteAmmo(TypeOfWeapon, bInfinite);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandSetPedInfiniteAmmoClip
|
|
// description: Enable/Disable infinite ammo for the specified ped
|
|
void CommandSetPedInfiniteAmmoClip(int PedIndex, bool bInfinite)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
|
|
|
|
if(pPed && CTheScripts::Frack())
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_INFINITE_AMMO_CLIP - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
// Store whether we want infinite clips or not
|
|
pPed->GetInventory()->GetAmmoRepository().SetUsingInfiniteClips(bInfinite);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandSetPedStunGunFiniteAmmo
|
|
// description: Enable/Disable finite ammo for WEAPON_STUNGUN for the specified ped, overriding metadata InfiniteAmmo value
|
|
void CommandSetPedStunGunFiniteAmmo(int PedIndex, bool bValue)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
|
|
|
|
if (pPed)
|
|
{
|
|
if (scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_STUN_GUN_FINITE_AMMO - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if (CTheScripts::Frack())
|
|
{
|
|
pPed->GetInventory()->GetAmmoRepository().SetIgnoreInfiniteAmmoFlag(ATSTRINGHASH("AMMO_STUNGUN", 0xB02EADE0), bValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandSetCurrentCharWeapon
|
|
// description: Set the current weapon a character has
|
|
void CommandSetCurrentPedWeapon(int PedIndex, int TypeOfWeapon, bool bForceInHand)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(pPed->GetInventory())
|
|
{
|
|
if(pPed->GetInventory()->GetWeapon(TypeOfWeapon))
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:SET_CURRENT_PED_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetWeaponManager()->EquipWeapon(TypeOfWeapon, -1, bForceInHand && pPed->GetVehiclePedInside() == NULL);
|
|
|
|
if(pPed->GetVehiclePedInside() || pPed->GetPedResetFlag(CPED_RESET_FLAG_IsClimbing))
|
|
{
|
|
// Ensure backup weapon is the same, so we will keep the selecting weapon if we are in a vehicle
|
|
pPed->GetWeaponManager()->SetBackupWeapon(TypeOfWeapon);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if !__FINAL
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
scriptAssertf(false, "%s:SET_CURRENT_PED_WEAPON - weapon does not exist in ped's inventory - Weapon:[%d][%s] Ped:[0x%p][%s][%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon, atHashString(TypeOfWeapon).TryGetCStr(), pPed, pPed->GetDebugName(), PedIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
scriptAssertf(false, "%s:SET_CURRENT_PED_WEAPON - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter());
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandGetCurrentPedWeapon
|
|
// description:
|
|
bool CommandGetCurrentPedWeapon(int PedIndex, int &ReturnWeaponType, bool DoDeadCheck)
|
|
{
|
|
unsigned assertFlags = CTheScripts::GUID_ASSERT_FLAGS_ALL;
|
|
if(!DoDeadCheck)
|
|
{
|
|
assertFlags = CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK;
|
|
}
|
|
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex, assertFlags);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_CURRENT_PED_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
ReturnWeaponType = pPed->GetWeaponManager()->GetEquippedWeaponHash();
|
|
|
|
// return whether the current weapon is usable (i.e. in their hand)
|
|
return ((u32)ReturnWeaponType==pPed->GetWeaponManager()->GetEquippedWeaponObjectHash());
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetCurrentPedWeaponEntityIndex
|
|
// description:
|
|
int CommandGetCurrentPedWeaponEntityIndex(int PedIndex, bool DoDeadCheck)
|
|
{
|
|
unsigned assertFlags = CTheScripts::GUID_ASSERT_FLAGS_ALL;
|
|
if(!DoDeadCheck)
|
|
{
|
|
assertFlags = CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK;
|
|
}
|
|
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex, assertFlags);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_CURRENT_PED_WEAPON_ENTITY_INDEX - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CObject* pWeaponObject = pPed->GetWeaponManager()->GetEquippedWeaponObject();
|
|
if( pWeaponObject )
|
|
return CTheScripts::GetGUIDFromEntity( const_cast<CObject&>(*pWeaponObject) );
|
|
}
|
|
}
|
|
return NULL_IN_SCRIPTING_LANGUAGE;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetBestPedWeapon
|
|
// description:
|
|
int CommandGetBestPedWeapon(int PedIndex, bool bIgnoreAmmoCheck)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_BEST_PED_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
return pPed->GetWeaponManager()->GetBestWeaponHash(0,bIgnoreAmmoCheck);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// name: CommandSetCurrentPedVehicleWeapon
|
|
// description: Set the current vehicle weapon ped can use
|
|
bool CommandSetCurrentPedVehicleWeapon(int PedIndex, int TypeOfWeapon)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:SET_CURRENT_PED_VEHICLE_WEAPON - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
// First attempt to set the vehicle weapon
|
|
if( pPed->GetIsInVehicle() )
|
|
{
|
|
CVehicle* pVehicle = pPed->GetMyVehicle();
|
|
CVehicleWeaponMgr* pVehicleWeaponMgr = pVehicle ? pVehicle->GetVehicleWeaponMgr() : NULL;
|
|
if( pVehicleWeaponMgr )
|
|
{
|
|
// Selected vehicle weapon index needs to be seat-relative
|
|
s32 nVehicleWeaponIndex = -1;
|
|
atArray<CVehicleWeapon*> vehicleWeapons;
|
|
pVehicleWeaponMgr->GetWeaponsForSeat(pVehicle->GetSeatManager()->GetPedsSeatIndex(pPed), vehicleWeapons);
|
|
for(int i= 0; i < vehicleWeapons.GetCount(); ++i)
|
|
{
|
|
if(vehicleWeapons[i]->GetHash() == (u32)TypeOfWeapon)
|
|
{
|
|
nVehicleWeaponIndex = i;
|
|
}
|
|
}
|
|
|
|
if( nVehicleWeaponIndex != -1 && pPed->GetWeaponManager()->EquipWeapon( 0, nVehicleWeaponIndex, false ) )
|
|
{
|
|
if(NetworkInterface::IsGameInProgress() && NetworkUtils::IsNetworkCloneOrMigrating(pVehicle))
|
|
{
|
|
CBlockWeaponSelectionEvent::Trigger(*pVehicle, true);
|
|
}
|
|
else
|
|
{
|
|
pVehicle->GetIntelligence()->BlockWeaponSelection(true);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetCurrentPedVehicleWeapon
|
|
// description: Retrieve the vehicle weapon the designated ped is currently using
|
|
bool CommandGetCurrentPedVehicleWeapon(int PedIndex, int &ReturnWeaponType)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_CURRENT_PED_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CVehicleWeapon* pWeapon = pPed->GetWeaponManager()->GetEquippedVehicleWeapon();
|
|
if( pWeapon )
|
|
{
|
|
ReturnWeaponType = pWeapon->GetHash();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CommandSetCycleVehicleWeaponsOnly(int PedIndex)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
|
|
if(pPed)
|
|
{
|
|
pPed->SetPedResetFlag(CPED_RESET_FLAG_OnlySelectVehicleWeapons, true);
|
|
}
|
|
}
|
|
|
|
enum eWeaponCheckFlags
|
|
{
|
|
WF_INCLUDE_MELEE = 1,
|
|
WF_INCLUDE_PROJECTILE = 2,
|
|
WF_INCLUDE_GUN = 4
|
|
};
|
|
|
|
bool CommandIsPedArmed(int PedIndex, int iCheckFlags)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
// Get the current weapon info
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:IS_PED_ARMED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
u32 weaponHash = pPed->GetWeaponManager()->GetEquippedWeaponHash();
|
|
|
|
// Ignore objects (phone etc...)
|
|
if( weaponHash == OBJECTTYPE_OBJECT )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Check for valid weapon
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(weaponHash);
|
|
if( pWeaponInfo == NULL || pWeaponInfo->GetIsUnarmed() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Check for melee weapons
|
|
if( (iCheckFlags & WF_INCLUDE_MELEE) && pWeaponInfo->GetIsMelee() )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Projectiles
|
|
if( (iCheckFlags & WF_INCLUDE_PROJECTILE) && pWeaponInfo->GetIsProjectile() )
|
|
{
|
|
return pPed->GetWeaponManager()->GetEquippedWeaponObject() != NULL;
|
|
}
|
|
|
|
// guns (including rocket launcher)
|
|
if( (iCheckFlags & WF_INCLUDE_GUN) && pWeaponInfo->GetIsGun())
|
|
{
|
|
return pPed->GetWeaponManager()->GetEquippedWeaponObject() != NULL;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// name: CommandHasPedGotWeapon
|
|
// description: Return if character has got a weapon
|
|
bool CommandIsWeaponValid(int TypeOfWeapon)
|
|
{
|
|
const CItemInfo* pInfo = CWeaponInfoManager::GetInfo(TypeOfWeapon ASSERT_ONLY(,true));
|
|
if (pInfo)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// name: CommandHasPedGotWeapon
|
|
// description: Return if character has got a weapon
|
|
bool CommandHasPedGotWeapon(int PedIndex, int TypeOfWeapon, int GeneralWeaponType)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
|
|
bool LatestCmpFlagResult = false;
|
|
|
|
if(pPed)
|
|
{
|
|
if (GeneralWeaponType > GENERALWEAPON_TYPE_INVALID)
|
|
{
|
|
scriptAssertf(GeneralWeaponType < NUM_GENERALWEAPON_TYPES, "Invalid general weapon type passed in");
|
|
scriptAssertf(TypeOfWeapon == 0, "If general weapon type is used, set weapon type to WEAPONTYPE_INVALID");
|
|
|
|
const CWeaponItemRepository& WeaponRepository = pPed->GetInventory()->GetWeaponRepository();
|
|
|
|
if (GENERALWEAPON_TYPE_ANYWEAPON == TypeOfWeapon)
|
|
{
|
|
for(int i=0; i<WeaponRepository.GetItemCount(); i++)
|
|
{
|
|
const CWeaponItem* pWeaponItem = WeaponRepository.GetItemByIndex(i);
|
|
Assert(pWeaponItem);
|
|
const CWeaponInfo* pWeaponInfo = pWeaponItem->GetInfo();
|
|
if (pWeaponInfo && !pWeaponInfo->GetIsUnarmed() )
|
|
{
|
|
LatestCmpFlagResult = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (GENERALWEAPON_TYPE_ANYMELEE == TypeOfWeapon)
|
|
{
|
|
for(int i=0; i<WeaponRepository.GetItemCount(); i++)
|
|
{
|
|
const CWeaponItem* pWeaponItem = WeaponRepository.GetItemByIndex(i);
|
|
Assert(pWeaponItem);
|
|
const CWeaponInfo* pWeaponInfo = pWeaponItem->GetInfo();
|
|
if (pWeaponInfo && !pWeaponInfo->GetIsUnarmed() && pWeaponInfo->GetIsMelee())
|
|
{
|
|
LatestCmpFlagResult = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(TypeOfWeapon != 0)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:HAS_PED_GOT_WEAPON - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if(pPed->GetInventory()->GetWeapon(TypeOfWeapon))
|
|
{
|
|
LatestCmpFlagResult = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return LatestCmpFlagResult;
|
|
}
|
|
|
|
bool CommandIsPedWeaponReadyToShoot(int PedIndex)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>( PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK );
|
|
if( pPed )
|
|
{
|
|
const CPedWeaponManager* pPedWeaponMgr = pPed->GetWeaponManager();
|
|
if( scriptVerifyf( pPedWeaponMgr, "%s:IS_PED_WEAPON_READY_TO_SHOOT - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
const CWeapon* pWeapon = pPedWeaponMgr->GetEquippedWeapon();
|
|
return pWeapon && pWeapon->GetState() == CWeapon::STATE_READY;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetWeaponTypeInSlot
|
|
// description: Return the weapon type in a given slot HASH for a given character
|
|
int CommandGetPedWeaponTypeInSlot(int PedGuid, int slotHash)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedGuid, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
|
|
if(pPed && pPed->GetInventory())
|
|
{
|
|
const CWeaponItem* pItem = pPed->GetInventory()->GetWeaponBySlot(slotHash);
|
|
if (pItem)
|
|
return pItem->GetInfo()->GetHash();
|
|
else
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// name: CommandGetAmmoInPedWeapon
|
|
// description: return the amount of ammo in a weapon held by a character
|
|
int CommandGetAmmoInPedWeapon(int PedIndex, int TypeOfWeapon)
|
|
{
|
|
int ReturnAmmo = 0;
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:GET_AMMO_IN_PED_WEAPON - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
ReturnAmmo = pPed->GetInventory()->GetWeaponAmmo(TypeOfWeapon);
|
|
}
|
|
}
|
|
return ReturnAmmo;
|
|
}
|
|
|
|
//
|
|
// name: CommandRemoveWeaponFromPed
|
|
// description: Remove weapon from character
|
|
void CommandRemoveWeaponFromPed(int PedIndex, int TypeOfWeapon)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAG_ENTITY_EXISTS);
|
|
|
|
if(pPed)
|
|
{
|
|
if (pPed->IsNetworkClone())
|
|
{
|
|
CRemoveWeaponEvent::Trigger(pPed, TypeOfWeapon);
|
|
return;
|
|
}
|
|
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:REMOVE_WEAPON_FROM_PED - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if(pPed->GetInventory()->RemoveWeapon(TypeOfWeapon))
|
|
{
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:REMOVE_WEAPON_FROM_PED: [%d][%s]: Ped 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon, atHashString(TypeOfWeapon).TryGetCStr(), pPed, pPed->GetDebugName(), PedIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
}
|
|
CTheScripts::Frack2();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// name: CommandRemoveAllCharWeapons
|
|
// description: Remove all weapons from character
|
|
void CommandRemoveAllPedWeapons(int PedIndex, bool DeadCheck)
|
|
{
|
|
g_WeaponAudioEntity.SetBlockSpinUpFrame(fwTimer::GetFrameCount());
|
|
unsigned flags = DeadCheck ? CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES : CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES & (~CTheScripts::GUID_ASSERT_FLAG_DEAD_CHECK);
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, flags);
|
|
|
|
if(pPed)
|
|
{
|
|
if (pPed->IsNetworkClone())
|
|
{
|
|
if(scriptVerifyf(!pPed->IsPlayer(), "Trying to remove all weapons from a remote player! This is not allowed for anti-cheat reasons!"))
|
|
{
|
|
CRemoveAllWeaponsEvent::Trigger(pPed);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
CPedInventoryLoadOutManager::SetDefaultLoadOut(pPed);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// name: CommandHideCharWeaponForScriptedCutscene
|
|
// description: Hide this peds weapons while playing a cutscene
|
|
void CommandHidePedWeaponForScriptedCutscene(int PedIndex, bool HideWeaponFlag)
|
|
{
|
|
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if (HideWeaponFlag)
|
|
{
|
|
pPed->GetWeaponManager()->DestroyEquippedWeaponObject(false);
|
|
}
|
|
else
|
|
{
|
|
if(!pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ))
|
|
{
|
|
pPed->GetWeaponManager()->EquipWeapon(pPed->GetWeaponManager()->GetEquippedWeaponHash(), -1, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandSetCharCurrentWeaponVisible
|
|
// description: Toggles the visibility of the peds currently equipped weapon
|
|
void CommandSetPedCurrentWeaponVisible(int PedIndex, bool VisibleFlag, bool DestroyObject, bool DeadCheck, bool bStoreDestroyedWeaponClipValue)
|
|
{
|
|
unsigned flags = DeadCheck ? CTheScripts::GUID_ASSERT_FLAGS_ALL : CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK;
|
|
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, flags);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:SET_PED_CURRENT_WEAPON_VISIBLE - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_KeepWeaponHolsteredUnlessFired, !VisibleFlag );
|
|
if(VisibleFlag)
|
|
{
|
|
if (pPed->GetWeaponManager()->GetEquippedWeaponObject())
|
|
pPed->GetWeaponManager()->GetEquippedWeaponObject()->SetIsVisibleForModule(SETISVISIBLE_MODULE_SCRIPT, true, true);
|
|
else
|
|
pPed->GetWeaponManager()->EquipWeapon(pPed->GetWeaponManager()->GetEquippedWeaponHash(), -1, true);
|
|
}
|
|
else
|
|
{
|
|
if (!DestroyObject && pPed->GetWeaponManager()->GetEquippedWeaponObject())
|
|
pPed->GetWeaponManager()->GetEquippedWeaponObject()->SetIsVisibleForModule(SETISVISIBLE_MODULE_SCRIPT, false, true);
|
|
else
|
|
{
|
|
// B*2295321: Cache ammo clip info for previous weapon (gets restored in CPedWeaponManager::CreateEquippedWeaponObject).
|
|
if (bStoreDestroyedWeaponClipValue && pPed->IsLocalPlayer() && pPed->GetEquippedWeaponInfo() && pPed->GetEquippedWeaponInfo()->GetUsesAmmo())
|
|
{
|
|
CWeaponItem* pPreviousWeaponItem = pPed->GetInventory() ? pPed->GetInventory()->GetWeapon(pPed->GetEquippedWeaponInfo()->GetHash()) : NULL;
|
|
if (pPreviousWeaponItem)
|
|
{
|
|
s32 iAmmoInClip = pPed->GetWeaponManager()->GetEquippedWeapon() ? pPed->GetWeaponManager()->GetEquippedWeapon()->GetAmmoInClip() : -1;
|
|
pPreviousWeaponItem->SetLastAmmoInClip(iAmmoInClip, pPed);
|
|
}
|
|
}
|
|
pPed->GetWeaponManager()->DestroyEquippedWeaponObject();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandSetPedDropsWeaponsWhenDead
|
|
// description: Set if this ped drops weapons when he dies
|
|
void CommandSetPedDropsWeaponsWhenDead(int PedIndex, bool DropsWeaponsFlag)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if (DropsWeaponsFlag)
|
|
{
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_DoesntDropWeaponsWhenDead, FALSE );
|
|
}
|
|
else
|
|
{
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_DoesntDropWeaponsWhenDead, TRUE );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandHasPedBeenDamagedByWeapon
|
|
// description:
|
|
bool CommandHasPedBeenDamagedByWeapon(int PedIndex, int TypeOfWeapon, int GeneralWeaponType)
|
|
{
|
|
const CPed *pPed= CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if (GeneralWeaponType > GENERALWEAPON_TYPE_INVALID)
|
|
{
|
|
scriptAssertf(GeneralWeaponType < NUM_GENERALWEAPON_TYPES, "Invalid general weapon type passed in");
|
|
scriptAssertf(TypeOfWeapon == 0, "If general weapon type is used, set weapon type to WEAPONTYPE_INVALID");
|
|
|
|
if(pPed->HasBeenDamagedByGeneralWeaponType(GeneralWeaponType))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pPed->HasBeenDamagedByHash((u32)TypeOfWeapon))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Displayf("HAS_PED_BEEN_DAMAGED_BY_WEAPON - Character doesn't exist\n");
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// name: CommandClearPedLastWeaponDamage
|
|
// description:
|
|
void CommandClearPedLastWeaponDamage(int PedIndex)
|
|
{
|
|
if (SCRIPT_VERIFY(!NetworkInterface::IsGameInProgress(), "CLEAR_PED_LAST_WEAPON_DAMAGE - This script command is not allowed in network game scripts"))
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
pPed->ResetWeaponDamageInfo();
|
|
}
|
|
else
|
|
{
|
|
Displayf("CLEAR_PED_LAST_WEAPON_DAMAGE - Character doesn't exist");
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandHasEntityBeenDamagedByWeapon
|
|
// description: Return if the entity has been damaged by a weapon type
|
|
bool CommandHasEntityBeenDamagedByWeapon(int EntityIndex, int TypeOfWeapon, int GeneralWeaponType)
|
|
{
|
|
const CPhysical *pEntity = CTheScripts::GetEntityToQueryFromGUID<CPhysical>(EntityIndex,CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
|
|
bool LatestCmpFlagResult = false;
|
|
|
|
if(pEntity)
|
|
{
|
|
if (GeneralWeaponType > GENERALWEAPON_TYPE_INVALID)
|
|
{
|
|
scriptAssertf(GeneralWeaponType < NUM_GENERALWEAPON_TYPES, "Invalid general weapon type passed in");
|
|
scriptAssertf(TypeOfWeapon == 0, "If general weapon type is used, set weapon type to WEAPONTYPE_INVALID");
|
|
|
|
if (pEntity->HasBeenDamagedByGeneralWeaponType(GeneralWeaponType))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pEntity->HasBeenDamagedByHash((u32)TypeOfWeapon))
|
|
{
|
|
LatestCmpFlagResult = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return LatestCmpFlagResult;
|
|
}
|
|
|
|
//
|
|
// name: CommandClearEntityLastWeaponDamage
|
|
// description: Clear weapon damage info on entity
|
|
void CommandClearEntityLastWeaponDamage(int EntityIndex)
|
|
{
|
|
if (SCRIPT_VERIFY(!NetworkInterface::IsGameInProgress(), "CLEAR_ENTITY_LAST_WEAPON_DAMAGE - This script command is not allowed in network game scripts"))
|
|
{
|
|
CPhysical *pEntity = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
|
|
|
|
if(pEntity)
|
|
{
|
|
pEntity->ResetWeaponDamageInfo();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandCharDropWeapon
|
|
// description: Drops the weapon the ped is currently holding
|
|
void CommandPedDropWeapon(int PedIndex)
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex );
|
|
|
|
if(pPed)
|
|
{
|
|
// Only shoot on impacts 50% of the time
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:SET_PED_DROPS_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if( !pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_StopWeaponFiringOnImpact ) && pPed->GetWeaponManager()->GetEquippedWeaponObject() )
|
|
{
|
|
CObject* pWeaponObject = pPed->GetWeaponManager()->GetEquippedWeaponObject();
|
|
pWeaponObject->m_nObjectFlags.bWeaponWillFireOnImpact = fwRandom::GetRandomTrueFalse();
|
|
weaponDebugf1("SET_PED_DROPS_WEAPON [0x%p] dropped by ped [0x%p]: bWeaponWillFireOnImpact %d", pWeaponObject, pPed, pWeaponObject->m_nObjectFlags.bWeaponWillFireOnImpact);
|
|
#if !__FINAL
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
}
|
|
}
|
|
|
|
CPedWeaponManager* pWeaponMgr = pPed->GetWeaponManager();
|
|
if(pWeaponMgr)
|
|
{
|
|
const CWeapon* pWeapon = pWeaponMgr->GetEquippedWeapon();
|
|
if(pWeapon && pWeapon->GetWeaponInfo()->GetPickupHash() != 0)
|
|
{
|
|
// Drop the weapon
|
|
CPickup *pPickup = CPickupManager::CreatePickUpFromCurrentWeapon(pPed);
|
|
|
|
if(pPickup)
|
|
{
|
|
// Need to call update here because otherwise the the pickup update won't happen till the next frame
|
|
// which will leave the pickup in the exterior for one frame even though the ped that dropped it may have been
|
|
// in an interior
|
|
pPickup->Update();
|
|
|
|
// Remove it from inventory
|
|
if(pPed->GetInventory())
|
|
{
|
|
pPed->GetInventory()->RemoveWeapon(pWeapon->GetWeaponHash());
|
|
}
|
|
|
|
// Equip best one
|
|
pWeaponMgr->EquipBestWeapon();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Displayf("SET_PED_DROPS_WEAPON - Character doesn't exist");
|
|
}
|
|
}
|
|
|
|
void CommandPedDropsInventoryWeapon(int PedIndex, int TypeOfWeapon, const scrVector & offset, int ammoAmount)
|
|
{
|
|
Vector3 vOffset(offset);
|
|
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex );
|
|
|
|
if(pPed)
|
|
{
|
|
CPedInventory* pedInventory = pPed->GetInventory();
|
|
|
|
CPedWeaponManager* pWeaponManager = pPed->GetWeaponManager();
|
|
CWeaponItem* pWeaponItem = pedInventory->GetWeapon(TypeOfWeapon);
|
|
const CWeaponInfo* pWeaponInfo = pWeaponItem ? pWeaponItem->GetInfo() : NULL;
|
|
|
|
if(scriptVerifyf(pWeaponManager, "%s:SET_PED_DROPS_INVENTORY_WEAPON - ped has no weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()) &&
|
|
scriptVerifyf(pWeaponItem, "%s:SET_PED_DROPS_INVENTORY_WEAPON - weapon is not in peds inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()) &&
|
|
scriptVerifyf(pWeaponInfo, "%s:SET_PED_DROPS_INVENTORY_WEAPON - weapon has no info", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
Vector3 pedPos = VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition());
|
|
Vector3 pickupPos = VEC3V_TO_VECTOR3(pPed->GetTransform().Transform(VECTOR3_TO_VEC3V(vOffset)));
|
|
|
|
// do a probe from the player to the pickup's position, we need to check that it will not be created behind a wall etc
|
|
const Vector3 vStart = pedPos + Vector3(0.0f, 0.0f, 0.5f);
|
|
const Vector3 vEnd = pickupPos;
|
|
|
|
WorldProbe::CShapeTestProbeDesc probeDesc;
|
|
WorldProbe::CShapeTestHitPoint probeHitPoint;
|
|
WorldProbe::CShapeTestResults probeResult(probeHitPoint);
|
|
probeDesc.SetResultsStructure(&probeResult);
|
|
probeDesc.SetStartAndEnd(vStart, vEnd);
|
|
probeDesc.SetExcludeInstance(pPed->GetCurrentPhysicsInst());
|
|
probeDesc.SetIncludeFlags(ArchetypeFlags::GTA_ALL_TYPES_MOVER);
|
|
|
|
Vector3 resultNormal;
|
|
Vector3 resultPosition;
|
|
bool probeHit = false;
|
|
|
|
// test world
|
|
probeHit = WorldProbe::GetShapeTestManager()->SubmitTest(probeDesc);
|
|
|
|
if(probeHit)
|
|
{
|
|
// if the probe hit, just place at the player's feet
|
|
pickupPos = pedPos;
|
|
}
|
|
|
|
Matrix34 m;
|
|
m.Identity();
|
|
m.RotateX(PI/2.0f);
|
|
m.d = pickupPos;
|
|
|
|
strLocalIndex customModelIndex = strLocalIndex(fwModelId::MI_INVALID);
|
|
|
|
// If we have a variation model component on the weapon, use that model for the pickup
|
|
const CWeaponComponentVariantModelInfo* pVariantInfo = pWeaponItem->GetComponentInfo<CWeaponComponentVariantModelInfo>();
|
|
bool bWeaponHasVarMod = false;
|
|
if (pVariantInfo)
|
|
{
|
|
// Make sure the model exists
|
|
fwModelId variantModelId;
|
|
CModelInfo::GetBaseModelInfoFromHashKey(pVariantInfo->GetModelHash(), &variantModelId);
|
|
if (weaponVerifyf(variantModelId.IsValid(), "ModelId is invalid for VariantModel component on [%s], using original model for pickup instead.", pWeaponInfo->GetName()))
|
|
{
|
|
customModelIndex = variantModelId.GetModelIndex();
|
|
bWeaponHasVarMod = true;
|
|
}
|
|
}
|
|
|
|
CPickup* pPickup = CPickupManager::CreatePickup( pWeaponInfo->GetPickupHash(), m, NULL, true, customModelIndex.Get(), false);
|
|
|
|
if( pPickup )
|
|
{
|
|
// Only create and set weapon for weapon type pickups.
|
|
bool bIsWeaponPickup = false;
|
|
for (u32 i=0; i<pPickup->GetPickupData()->GetNumRewards(); i++)
|
|
{
|
|
const CPickupRewardData* pReward = pPickup->GetPickupData()->GetReward(i);
|
|
if (pReward && pReward->GetType() == PICKUP_REWARD_TYPE_WEAPON)
|
|
{
|
|
bIsWeaponPickup = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( bIsWeaponPickup )
|
|
{
|
|
if (!pPickup->GetWeapon())
|
|
{
|
|
pPickup->SetWeapon(WeaponFactory::Create(pWeaponInfo->GetHash(), ammoAmount, pPickup, "CommandPedDropsInventoryWeapon"));
|
|
}
|
|
if(pPickup->GetWeapon())
|
|
{
|
|
pPickup->GetWeapon()->GetAudioComponent().SetWasDropped(true);
|
|
}
|
|
|
|
pPickup->SetAmount(ammoAmount);
|
|
|
|
// Make sure pickup has correct attachments
|
|
const CWeaponItem::Components* pComponents = pWeaponItem->GetComponents();
|
|
|
|
if (pComponents)
|
|
{
|
|
// B*2334397: If we have a var mod, attach that first so that we create other components with the correct model.
|
|
if (bWeaponHasVarMod)
|
|
{
|
|
for( s32 i = 0; i < pComponents->GetCount(); i++ )
|
|
{
|
|
const CWeaponComponentInfo *pComponentInfo = (*pComponents)[i].pComponentInfo;
|
|
if (pComponentInfo && pComponentInfo->GetIsClassId(CWeaponComponentVariantModelInfo::GetStaticClassId()))
|
|
{
|
|
CPedEquippedWeapon::CreateWeaponComponent(pComponentInfo->GetHash(), pPickup );
|
|
}
|
|
}
|
|
}
|
|
|
|
for( s32 i = 0; i < pComponents->GetCount(); i++ )
|
|
{
|
|
// Don't try to re-create the var mod.
|
|
bool bIsVarModComponent = (*pComponents)[i].pComponentInfo->GetIsClassId(CWeaponComponentVariantModelInfo::GetStaticClassId());
|
|
if (!bWeaponHasVarMod || (bWeaponHasVarMod && !bIsVarModComponent))
|
|
{
|
|
CPedEquippedWeapon::CreateWeaponComponent( (*pComponents)[i].pComponentInfo->GetHash(), pPickup );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the correct rendering flags now whole hierarchy has been made (so attachments are set).
|
|
pPickup->SetForceAlphaAndUseAmbientScale();
|
|
// Set up the glow too.
|
|
pPickup->SetUseLightOverrideForGlow();
|
|
|
|
// Make sure pickup has correct tint
|
|
if( pPickup->GetWeapon() )
|
|
{
|
|
pPickup->GetWeapon()->UpdateShaderVariables( pWeaponItem->GetTintIndex() );
|
|
}
|
|
}
|
|
|
|
pPickup->SetLastOwner(pPed);
|
|
|
|
pPickup->SetDontFadeOut();
|
|
|
|
if (pPed->IsLocalPlayer())
|
|
{
|
|
if (!pPickup->GetPickupData()->GetRequiresButtonPressToPickup())
|
|
{
|
|
pPickup->SetDroppedFromLocalPlayer();
|
|
}
|
|
pPickup->SetPlayerGift();
|
|
}
|
|
|
|
// Need to call update here because otherwise the the pickup update won't happen till the next frame
|
|
// which will leave the pickup in the exterior for one frame even though the ped that dropped it may have been
|
|
// in an interior
|
|
pPickup->Update();
|
|
|
|
const CWeapon* pEquippedWeapon = pWeaponManager->GetEquippedWeapon();
|
|
|
|
bool bDroppingEquipped = pEquippedWeapon && pEquippedWeapon->GetWeaponInfo() == pWeaponInfo;
|
|
|
|
// Remove it from inventory
|
|
pedInventory->RemoveWeapon(TypeOfWeapon);
|
|
|
|
// Equip best one if the dropped weapon was the one held
|
|
if (bDroppingEquipped)
|
|
{
|
|
pWeaponManager->EquipBestWeapon();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Displayf("SET_PED_DROPS_INVENTORY_WEAPON - Ped doesn't exist");
|
|
}
|
|
}
|
|
|
|
//
|
|
// name: CommandGetMaxAmmoInClip
|
|
// description: How many is the max amount of bullets allowed in the clip
|
|
// return true if the weapon type is equipped false otherwise
|
|
int CommandGetMaxAmmoInClip(int PedIndex, int TypeOfWeapon, bool DoDeadCheck)
|
|
{
|
|
int MaxAmountOfAmmoInClip = 0;
|
|
|
|
unsigned assertFlags = CTheScripts::GUID_ASSERT_FLAGS_ALL;
|
|
if(!DoDeadCheck)
|
|
{
|
|
assertFlags = CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK;
|
|
}
|
|
|
|
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex, assertFlags);
|
|
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (pWeaponInfo)
|
|
{
|
|
MaxAmountOfAmmoInClip = pWeaponInfo->GetClipSize();
|
|
}
|
|
|
|
// Try to find the weapon from inventory and use the clip component since a weapon can have different clip size now.
|
|
const CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if (pWeaponItem)
|
|
{
|
|
if (pWeaponItem->GetComponents())
|
|
{
|
|
const CWeaponItem::Components& components = *pWeaponItem->GetComponents();
|
|
for (s32 i = components.GetCount()-1; i >= 0; i--)
|
|
{
|
|
if (components[i].pComponentInfo->GetIsClass<CWeaponComponentClipInfo>())
|
|
{
|
|
MaxAmountOfAmmoInClip = static_cast<const CWeaponComponentClipInfo*>(components[i].pComponentInfo)->GetClipSize();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return MaxAmountOfAmmoInClip;
|
|
}
|
|
|
|
//
|
|
// name: CommandGetAmmoInClip
|
|
// description: How many bullets are in the clip
|
|
// return true if the weapon type is equipped false otherwise
|
|
bool CommandGetAmmoInClip(int PedIndex, int TypeOfWeapon, int &AmountOfAmmoInClip)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_AMMO_IN_CLIP - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
AmountOfAmmoInClip = 0;
|
|
if(pPed->GetWeaponManager()->GetEquippedWeapon()
|
|
&& pPed->GetWeaponManager()->GetEquippedWeapon()->GetWeaponHash() == (u32)TypeOfWeapon)
|
|
{
|
|
AmountOfAmmoInClip = pPed->GetWeaponManager()->GetEquippedWeapon()->GetAmmoInClip();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
//
|
|
// name: CommandSetAmmoInClip
|
|
// description: Give ammo to character
|
|
// return true if the weapon type is equipped false otherwise
|
|
bool CommandSetAmmoInClip(int PedIndex, int TypeOfWeapon, int NewAmmoInClip)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:SET_AMMO_IN_CLIP - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeapon* pWeaponUsable = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
if (pWeaponUsable && pWeaponUsable->GetWeaponHash() == (u32)TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (pWeaponInfo)
|
|
{
|
|
// Clamp to the maximum allowed in the clip
|
|
int iMaxAmmoInClip = pWeaponInfo->GetClipSize();
|
|
if (NewAmmoInClip > iMaxAmmoInClip)
|
|
{
|
|
NewAmmoInClip = iMaxAmmoInClip;
|
|
}
|
|
|
|
// Get the old amount of ammo in the clip
|
|
int iOldAmmoInClip = pWeaponUsable->GetAmmoInClip();
|
|
|
|
// Set the new amount of ammo in the clip
|
|
pWeaponUsable->SetAmmoInClip(NewAmmoInClip);
|
|
|
|
// Get the new amount of ammo. Just in case we got less than we requested for some reason
|
|
int iAmmoInClip = pWeaponUsable->GetAmmoInClip();
|
|
|
|
// Calculate how much ammo we added
|
|
int iAmmoAdded = iAmmoInClip - iOldAmmoInClip;
|
|
|
|
// Add the new ammo to the total
|
|
if(pPed->GetInventory())
|
|
pPed->GetInventory()->AddWeaponAmmo(TypeOfWeapon, iAmmoAdded);
|
|
|
|
// We have specifically set ammo in the clip, so quit reloading if we are reloading
|
|
switch(pWeaponUsable->GetState())
|
|
{
|
|
case CWeapon::STATE_RELOADING:
|
|
case CWeapon::STATE_OUT_OF_AMMO:
|
|
pWeaponUsable->SetState(CWeapon::STATE_READY);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if(pPed->IsPlayer() && CNewHud::IsUsingWeaponWheel() && CNewHud::GetWheelDisableReload())
|
|
{
|
|
if((u32)TypeOfWeapon == CNewHud::GetWheelWeaponInHand())
|
|
{
|
|
CNewHud::SetWheelDisableReload(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandGetMaxAmmo(int PedIndex, int TypeOfWeapon, int &MaxAmmo)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (pWeaponInfo)
|
|
{
|
|
MaxAmmo = pWeaponInfo->GetAmmoMax(pPed);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandGetMaxAmmoByType(int PedIndex, int TypeOfAmmo, int &MaxAmmo)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
const CAmmoInfo* pAmmoInfo = CWeaponInfoManager::GetInfo<CAmmoInfo>((u32)TypeOfAmmo);
|
|
if (pAmmoInfo)
|
|
{
|
|
MaxAmmo = pAmmoInfo->GetAmmoMax(pPed);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CommandAddPedAmmoByType(int PedIndex, int TypeOfAmmo, int AmountOfAmmo)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK );
|
|
if( pPed )
|
|
{
|
|
CPedInventory* pPedInventory = pPed->GetInventory();
|
|
if( scriptVerifyf( pPedInventory, "%s:ADD_PED_AMMO_BY_TYPE - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
pPedInventory->AddAmmo(TypeOfAmmo, AmountOfAmmo);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandSetPedAmmoByType(int PedIndex, int TypeOfAmmo, int AmountOfAmmo)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK );
|
|
if( pPed )
|
|
{
|
|
CPedInventory* pPedInventory = pPed->GetInventory();
|
|
if( scriptVerifyf( pPedInventory, "%s:SET_PED_AMMO_BY_TYPE - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
pPedInventory->SetAmmo(TypeOfAmmo, AmountOfAmmo);
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetPedAmmoByType( int PedIndex, int TypeOfAmmo )
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK );
|
|
if( pPed )
|
|
{
|
|
const CPedInventory* pPedInventory = pPed->GetInventory();
|
|
if( scriptVerifyf( pPedInventory, "%s:GET_PED_AMMO_BY_TYPE - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
return pPedInventory->GetAmmo( TypeOfAmmo );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CommandSetPedAmmoToDrop( int PedIndex, int AmmoAmount )
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK );
|
|
if( pPed )
|
|
{
|
|
if( scriptVerifyf(pPed->GetNetworkObject(), "%s: SET_PED_AMMO_TO_DROP only works in MP at the moment", CTheScripts::GetCurrentScriptNameAndProgramCounter()) &&
|
|
scriptVerifyf(AmmoAmount >= 0, "%s: SET_PED_AMMO_TO_DROP - AmmoAmount is negative", CTheScripts::GetCurrentScriptNameAndProgramCounter()) &&
|
|
scriptVerifyf(AmmoAmount < 128, "%s: SET_PED_AMMO_TO_DROP - AmmoAmount is too large", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
static_cast<CNetObjPed*>(pPed->GetNetworkObject())->SetAmmoToDrop((u32)AmmoAmount);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandSetPickupAmmoAmountScaler(float fScale )
|
|
{
|
|
CPickupManager::SetPickupAmmoAmountScaler(fScale);
|
|
}
|
|
|
|
int CommandGetPedAmmoTypeFromWeapon( int PedIndex, int TypeOfWeapon )
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK );
|
|
if( pPed )
|
|
{
|
|
const CPedInventory* pPedInventory = pPed->GetInventory();
|
|
if( scriptVerifyf( pPedInventory, "%s:GET_PED_AMMO_TYPE_FROM_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (pWeaponInfo)
|
|
{
|
|
if( scriptVerifyf(pWeaponInfo->GetAmmoInfo(pPed), "%s:GET_PED_AMMO_TYPE_FROM_WEAPON - the weapon [%s] does not have ammo info.", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
return pWeaponInfo->GetAmmoInfo(pPed)->GetHash();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int CommandGetPedOriginalAmmoTypeFromWeapon( int PedIndex, int TypeOfWeapon )
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( PedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK );
|
|
if( pPed )
|
|
{
|
|
const CPedInventory* pPedInventory = pPed->GetInventory();
|
|
if( scriptVerifyf( pPedInventory, "%s:GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (pWeaponInfo)
|
|
{
|
|
if( scriptVerifyf(pWeaponInfo->GetAmmoInfo(), "%s:GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON - the weapon [%s] does not have ammo info.", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
return pWeaponInfo->GetAmmoInfo()->GetHash();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool CommandGetPedLastWeaponImpactCoord (int PedIndex, Vector3 &vImpactCoord)
|
|
{
|
|
bool bValidImpact = false;
|
|
vImpactCoord.Zero();
|
|
|
|
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if (pPed)
|
|
{
|
|
// check that the weapon was fired in the previous frame, this is used rather than the current frame as the weapon firing is
|
|
// generally carried out in the post-physics update (at the end of the frame) and the script update (where this fn is called) happens
|
|
// at the beginning of the frame.
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_PED_LAST_WEAPON_IMPACT_COORD - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
int iTimeBetweenImpact = fwTimer::GetPrevElapsedTimeInMilliseconds() - pPed->GetWeaponManager()->GetLastWeaponImpactTime();
|
|
|
|
if (iTimeBetweenImpact == 0)
|
|
{
|
|
vImpactCoord = pPed->GetWeaponManager()->GetLastWeaponImpactPos();
|
|
bValidImpact = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bValidImpact;
|
|
}
|
|
|
|
void CommandSetPedGadget(int PedIndex, int GadgetHash, bool bEquip)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_GADGET - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if(pPed->GetInventory()->GetWeapon(GadgetHash))
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:SET_PED_GADGET - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetWeaponManager()->EquipWeapon(GadgetHash, -1, bEquip);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
scriptAssertf(false, "%s:Ped does not have the specified gadget", CTheScripts::GetCurrentScriptNameAndProgramCounter());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s32 CommandGetSelectedPedWeapon(int PedIndex)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_SELECTED_PED_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
return static_cast<s32>(pPed->GetWeaponManager()->GetSelectedWeaponHash());
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool CommandGetIsPedGadgetEquipped(int PedIndex, int GadgetHash)
|
|
{
|
|
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_IS_PED_GADGET_EQUIPPED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
return pPed->GetWeaponManager()->GetIsGadgetEquipped(GadgetHash);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CommandExplodeProjectiles(int PedIndex, int WeaponType, bool bInstant)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
// Get the projectile type from the WeaponType
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(WeaponType);
|
|
if(scriptVerifyf(pWeaponInfo, "%s: WeaponType [%d] isn't valid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponType))
|
|
{
|
|
if(scriptVerifyf(pWeaponInfo->GetFireType() == FIRE_TYPE_PROJECTILE, "%s: WeaponType [%s] isn't a projectile weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
const CItemInfo* pAmmoInfo = pWeaponInfo->GetAmmoInfo();
|
|
if(scriptVerifyf(pAmmoInfo, "%s: WeaponType [%s] doesn't have ammo", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
if(scriptVerifyf(pAmmoInfo->GetIsClassId(CAmmoProjectileInfo::GetStaticClassId()), "%s: WeaponType [%s] Ammo [%s] isn't a projectile type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName(), pAmmoInfo->GetName()))
|
|
{
|
|
CProjectileManager::ExplodeProjectiles(pPed, pAmmoInfo->GetHash(), bInstant);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandRemoveAllProjectilesOfType(int WeaponType, bool bExplode)
|
|
{
|
|
// Get the projectile type from the WeaponType
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(WeaponType);
|
|
if(scriptVerifyf(pWeaponInfo, "%s: WeaponType [%d] isn't valid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponType))
|
|
{
|
|
const CItemInfo* pAmmoInfo = pWeaponInfo->GetAmmoInfo();
|
|
if(scriptVerifyf(pAmmoInfo, "%s: WeaponType [%s] doesn't have ammo", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
if(scriptVerifyf(pAmmoInfo->GetIsClassId(CAmmoProjectileInfo::GetStaticClassId()), "%s: WeaponType [%s] Ammo [%s] isn't a projectile type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName(), pAmmoInfo->GetName()))
|
|
{
|
|
CProjectileManager::RemoveAllProjectilesByAmmoType(pAmmoInfo->GetHash(), bExplode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandActivateDetonator(int PedIndex, bool Active)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:ACTIVATE_DETONATOR - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetWeaponManager()->SetDetonatorActive(Active);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CommandGetIsDetonatorFired(int PedIndex)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_IS_DETONATOR_FIRED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeapon* pWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
if(pWeapon)
|
|
{
|
|
const u32 WEAPON_BOMB_DETONATOR = ATSTRINGHASH("WEAPON_BOMB_DETONATOR", 0x08613f94c);
|
|
if(pWeapon->GetWeaponHash() == WEAPON_BOMB_DETONATOR)
|
|
{
|
|
const CTaskDetonator* pTask = static_cast<const CTaskDetonator*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_DETONATOR));
|
|
if(pTask && pTask->GetHasFired())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CommandGetIsStickyCamViewerFired(int PedIndex)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_IS_STICKY_CAM_VIEWER_FIRED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeapon* pWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
if(pWeapon)
|
|
{
|
|
const u32 GADGET_STICKY_CAM_VIEWER = ATSTRINGHASH("GADGET_STICKY_CAM_VIEWER", 0x0db77c490);
|
|
if(pWeapon->GetWeaponHash() == GADGET_STICKY_CAM_VIEWER)
|
|
{
|
|
const CTaskDetonator* pTask = static_cast<const CTaskDetonator*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_DETONATOR));
|
|
if(pTask && pTask->GetHasFired())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
float CommandGetLockOnDistanceOfCurrentPedWeapon(int PedIndex)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeapon* pWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
if(pWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(pWeapon->GetWeaponHash());
|
|
if(pWeaponInfo)
|
|
{
|
|
return pWeaponInfo->GetLockOnRange();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1.0f;
|
|
}
|
|
|
|
float CommandGetMaxRangeOfCurrentPedWeapon(int PedIndex)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_MAX_RANGE_OF_CURRENT_PED_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeapon* pWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
if(pWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(pWeapon->GetWeaponHash());
|
|
if(pWeaponInfo)
|
|
{
|
|
return pWeaponInfo->GetRange();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1.0f;
|
|
}
|
|
|
|
bool CommandHasVehicleGotProjectileAttached(int PedIndex, int VehicleIndex, int WeaponType, int DoorNumber)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
const CVehicle *pVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(VehicleIndex);
|
|
|
|
if(pVehicle)
|
|
{
|
|
u32 uProjectileHash = 0;
|
|
|
|
// Get the projectile hash from the WeaponType, if one is specified
|
|
if(WeaponType != 0)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(WeaponType);
|
|
if(scriptVerifyf(pWeaponInfo, "%s: WeaponType [%d] isn't valid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponType))
|
|
{
|
|
if(scriptVerifyf(pWeaponInfo->GetFireType() == FIRE_TYPE_PROJECTILE, "%s: WeaponType [%s] isn't a projectile weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
const CItemInfo* pAmmoInfo = pWeaponInfo->GetAmmoInfo();
|
|
if(scriptVerifyf(pAmmoInfo, "%s: WeaponType [%s] doesn't have ammo", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
if(scriptVerifyf(pAmmoInfo->GetIsClassId(CAmmoProjectileInfo::GetStaticClassId()), "%s: WeaponType [%s] Ammo [%s] isn't a projectile type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName(), pAmmoInfo->GetName()))
|
|
{
|
|
uProjectileHash = pAmmoInfo->GetHash();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s32 iDoorBone = -1;
|
|
|
|
// Get the component from the door number, if one is specified
|
|
if(DoorNumber != SC_DOOR_INVALID)
|
|
{
|
|
eHierarchyId nDoorId = CCarDoor::GetScriptDoorId(eScriptDoorList(DoorNumber));
|
|
iDoorBone = pVehicle->GetBoneIndex(nDoorId);
|
|
}
|
|
|
|
return CProjectileManager::GetIsProjectileAttachedToEntity(pPed, pVehicle, uProjectileHash, iDoorBone);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CommandGiveWeaponComponentToPed(int PedIndex, int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:GIVE_WEAPON_COMPONENT_TO_PED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory()->GetWeaponRepository().AddComponent(TypeOfWeapon, TypeOfComponent), "%s:GIVE_WEAPON_COMPONENT_TO_PED - Failed to give weapon component to ped", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:GIVE_WEAPON_COMPONENT_TO_PED: [%d][%s], [%d][%s]: Ped 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon, atHashString(TypeOfWeapon).TryGetCStr(), TypeOfComponent, atHashString(TypeOfComponent).TryGetCStr(), pPed, pPed->GetDebugName(), PedIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandRemoveWeaponComponentFromPed(int PedIndex, int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:REMOVE_WEAPON_COMPONENT_FROM_PED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory()->GetWeaponRepository().RemoveComponent(TypeOfWeapon, TypeOfComponent), "%s:REMOVE_WEAPON_COMPONENT_FROM_PED - Failed to remove weapon component from ped", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:REMOVE_WEAPON_COMPONENT_FROM_PED: [%d][%s], [%d][%s]: Ped 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon, atHashString(TypeOfWeapon).TryGetCStr(), TypeOfComponent, atHashString(TypeOfComponent).TryGetCStr(), pPed, pPed->GetDebugName(), PedIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CommandHasPedGotWeaponComponent(int PedIndex, int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:HAS_PED_GOT_WEAPON_COMPONENT - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if(pWeaponItem)
|
|
{
|
|
if(pWeaponItem->GetComponents())
|
|
{
|
|
const CWeaponItem::Components& components = *pWeaponItem->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(components[i].pComponentInfo->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandIsPedWeaponComponentActive(int PedIndex, int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:IS_PED_WEAPON_COMPONENT_ACTIVE - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if(pWeaponItem)
|
|
{
|
|
if(pWeaponItem->GetComponents())
|
|
{
|
|
const CWeaponItem::Components& components = *pWeaponItem->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(components[i].pComponentInfo->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
return components[i].m_bActive;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandGetPedCurrentWeaponTimeBeforeNextShot(int PedIndex, int &TimeBeforeNextShot)
|
|
{
|
|
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
const CPedWeaponManager* pWeaponManager = pPed->GetWeaponManager();
|
|
if(pWeaponManager)
|
|
{
|
|
const CWeapon* pEquippedWeapon = pWeaponManager->GetEquippedWeapon();
|
|
if(pEquippedWeapon)
|
|
{
|
|
f32 fTimeBeforeNextShot = pEquippedWeapon->GetTimeBeforeNextShot();
|
|
TimeBeforeNextShot = static_cast<s32>(fTimeBeforeNextShot * 1000.f);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandRefillAmmoInstant(int PedIndex)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
scriptAssertf(pPed->GetWeaponManager(), "%s: REFILL_AMMO_INSTANTLY - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter());
|
|
return CWeapon::RefillPedsWeaponAmmoInstant(*pPed);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandMakePedReload(int PedIndex)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed && scriptVerifyf(pPed->IsPlayer(), "%s: MAKE_PED_RELOAD - not implemented for AI peds yet", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CPedWeaponManager* pWeaponMgr = pPed->GetWeaponManager();
|
|
if(scriptVerifyf(pWeaponMgr, "%s: MAKE_PED_RELOAD - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeapon* pWeapon = pWeaponMgr->GetEquippedWeapon();
|
|
if(pWeapon && pWeapon->GetCanReload())
|
|
{
|
|
pPed->SetPedConfigFlag(CPED_CONFIG_FLAG_ForceReload, true);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void RequestWeaponAsset( int iWeaponHash, int iWeaponRequestFlags, int iExtraComponentFlags )
|
|
{
|
|
if( scriptVerifyf( iWeaponHash != 0, "REQUEST_WEAPON_ASSET - %s Weapon type [%d] is invalid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), iWeaponHash ) )
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>( iWeaponHash );
|
|
if( scriptVerifyf( pWeaponInfo, "REQUEST_WEAPON_ASSET - %s Weapon type [%d] does not exist in data", CTheScripts::GetCurrentScriptNameAndProgramCounter(), iWeaponHash ) )
|
|
{
|
|
CScriptResource_Weapon_Asset weaponAsset( iWeaponHash, iWeaponRequestFlags, iExtraComponentFlags );
|
|
CTheScripts::GetCurrentGtaScriptHandler()->RegisterScriptResource( weaponAsset );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool HasWeaponAssetLoaded(int weaponHash)
|
|
{
|
|
if(scriptVerifyf(weaponHash != 0, "HAS_WEAPON_ASSET_LOADED - %s Weapon type [%d] is invalid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), weaponHash))
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(weaponHash);
|
|
if(scriptVerifyf(pWeaponInfo, "HAS_WEAPON_ASSET_LOADED - %s Weapon type [%d] does not exist in data", CTheScripts::GetCurrentScriptNameAndProgramCounter(), weaponHash))
|
|
{
|
|
if(CTheScripts::GetCurrentGtaScriptHandler())
|
|
{
|
|
scriptResource* pScriptResource = CTheScripts::GetCurrentGtaScriptHandler()->GetScriptResource(CGameScriptResource::SCRIPT_RESOURCE_WEAPON_ASSET, weaponHash);
|
|
if(scriptVerifyf(pScriptResource, "HAS_WEAPON_ASSET_LOADED - %s has not requested %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
|
|
{
|
|
if(scriptVerifyf(pScriptResource->GetType() == CGameScriptResource::SCRIPT_RESOURCE_WEAPON_ASSET, "HAS_WEAPON_ASSET_LOADED - %s incorrect type of resource %d", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pScriptResource->GetType()))
|
|
{
|
|
CScriptResource_Weapon_Asset* pWeaponAsset = static_cast<CScriptResource_Weapon_Asset*>(pScriptResource);
|
|
CWeaponScriptResource* pWeaponResource = CWeaponScriptResourceManager::GetResource(pWeaponAsset->GetReference());
|
|
if(scriptVerifyf(pWeaponResource, "HAS_WEAPON_ASSET_LOADED - %s NULL resource", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
return pWeaponResource->GetIsStreamedIn();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void RemoveWeaponAsset( int iWeaponHash )
|
|
{
|
|
if( scriptVerifyf( iWeaponHash != 0, "REMOVE_WEAPON_ASSET - %s Weapon type [%d] is invalid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), iWeaponHash ) )
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>( iWeaponHash );
|
|
if( scriptVerifyf( pWeaponInfo, "REMOVE_WEAPON_ASSET - %s Weapon type [%d] does not exist in data", CTheScripts::GetCurrentScriptNameAndProgramCounter(), iWeaponHash ) )
|
|
{
|
|
CTheScripts::GetCurrentGtaScriptHandler()->RemoveScriptResource( CGameScriptResource::SCRIPT_RESOURCE_WEAPON_ASSET, iWeaponHash );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CommandHasPedGotWeaponManager(int PedIndex)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
|
|
if(pPed)
|
|
{
|
|
return pPed->GetWeaponManager() != NULL;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int CommandCreateWeaponObject(int TypeOfWeapon, int AmountOfAmmo, const scrVector & scrVecNewCoors, bool CreateDefaultComponents, float fScale, int ModelHash, bool RegisterAsNetworkObject, bool ScriptHostObject)
|
|
{
|
|
Matrix34 m(Matrix34::IdentityType);
|
|
m.d = Vector3(scrVecNewCoors);
|
|
|
|
CObject* pWeaponObject = CPedEquippedWeapon::CreateObject(TypeOfWeapon, AmountOfAmmo, m, CreateDefaultComponents, NULL, ModelHash, NULL, fScale, true);
|
|
if(scriptVerifyf(pWeaponObject, "CREATE_WEAPON_OBJECT - %s Failed to create weapon type [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
// non-networked objects should always be treated as client objects
|
|
if (!RegisterAsNetworkObject)
|
|
ScriptHostObject = false;
|
|
|
|
if(RegisterAsNetworkObject && NetworkInterface::IsGameInProgress())
|
|
{
|
|
if(!NetworkInterface::RegisterObject(pWeaponObject, 0, CNetObjGame::GLOBALFLAG_SCRIPTOBJECT, true))
|
|
{
|
|
gnetAssertf(0, "Failed to create network object for weapon type:%d", TypeOfWeapon);
|
|
}
|
|
}
|
|
|
|
CTheScripts::RegisterEntity(pWeaponObject, ScriptHostObject, RegisterAsNetworkObject);
|
|
|
|
int ObjectIndex = CTheScripts::GetGUIDFromEntity(*pWeaponObject);
|
|
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:CREATE_WEAPON_OBJECT: [%d][%s], Ammo:%d: Object 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon, atHashString(TypeOfWeapon).TryGetCStr(), AmountOfAmmo, pWeaponObject, pWeaponObject->GetModelName(), ObjectIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
|
|
return ObjectIndex;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CommandGiveWeaponComponentToWeaponObject(int ObjectIndex, int TypeOfComponent)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(CPedEquippedWeapon::CreateWeaponComponent(TypeOfComponent, pObject), "GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT - %s Failed to create weapon component type [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfComponent))
|
|
{
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT: [%d][%s]: Object 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfComponent, atHashString(TypeOfComponent).TryGetCStr(), pObject, pObject->GetModelName(), ObjectIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandRemoveWeaponComponentFromWeaponObject(int ObjectIndex, int TypeOfComponent)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT - %s Object is not a weapon object", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeaponComponent* pComponentToRemove = NULL;
|
|
const CWeapon::Components& components = pObject->GetWeapon()->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(components[i]->GetInfo()->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
pComponentToRemove = components[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(scriptVerifyf(pComponentToRemove, "REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT - %s Object does not contain component", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CPedEquippedWeapon::DestroyWeaponComponent(pObject, pComponentToRemove);
|
|
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT: [%d][%s]: Object 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfComponent, atHashString(TypeOfComponent).TryGetCStr(), pObject, pObject->GetModelName(), ObjectIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CommandHasWeaponGotWeaponComponent(int ObjectIndex, int TypeOfComponent)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "HAS_WEAPON_GOT_WEAPON_COMPONENT - %s Object [%s][0x%p][%d] has no weapon, is pickup [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName(), pObject, ObjectIndex, pObject->GetIsClass<CPickup>()))
|
|
{
|
|
const CWeapon::Components& components = pObject->GetWeapon()->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(components[i]->GetInfo()->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const char* CommandGetWeaponComponentName(int uHashOfComponent)
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(uHashOfComponent);
|
|
if(scriptVerifyf(pComponentInfo, "GET_WEAPON_COMPONENT_NAME - Component with Hash %i (0x%08x) could not be found!", uHashOfComponent, uHashOfComponent) )
|
|
{
|
|
return pComponentInfo->GetLocKey().GetCStr();
|
|
}
|
|
|
|
return "WCT_INVALID";
|
|
}
|
|
|
|
const char* CommandGetWeaponComponentDescription(int uHashOfComponent)
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(uHashOfComponent);
|
|
if(scriptVerifyf(pComponentInfo, "GET_WEAPON_COMPONENT_DESCRIPTION - Component with Hash %i (0x%08x) could not be found!", uHashOfComponent, uHashOfComponent) )
|
|
{
|
|
return pComponentInfo->GetLocDesc().GetCStr();
|
|
}
|
|
|
|
return "WCD_INVALID";
|
|
}
|
|
|
|
void CommandGiveWeaponObjectToPed(int ObjectIndex, int PedIndex)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "GIVE_WEAPON_OBJECT_TO_PED - %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "GIVE_WEAPON_OBJECT_TO_PED - %s Ped [%s] has no inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetDebugName()))
|
|
{
|
|
CWeaponItem* pWeaponItem = pPed->GetInventory()->AddWeaponAndAmmo(pWeapon->GetWeaponHash(), pWeapon->GetAmmoTotal());
|
|
if(scriptVerifyf(pWeaponItem, "GIVE_WEAPON_OBJECT_TO_PED - %s Failed to give weapon to ped", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeapon::Components& components = pWeapon->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory()->GetWeaponRepository().AddComponent(pWeapon->GetWeaponHash(), components[i]->GetInfo()->GetHash()), "GIVE_WEAPON_OBJECT_TO_PED - %s Failed to give weapon component to ped", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
}
|
|
}
|
|
|
|
// Copy over the tint index
|
|
pWeaponItem->SetTintIndex(pWeapon->GetTintIndex());
|
|
|
|
#if !__FINAL
|
|
weaponDebugf1("%s:GIVE_WEAPON_OBJECT_TO_PED: Ped 0x%p [%s] [%d], Object 0x%p [%s] [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed, pPed->GetDebugName(), PedIndex, pObject, pObject->GetModelName(), ObjectIndex);
|
|
scrThread::PrePrintStackTrace();
|
|
#endif
|
|
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "GIVE_WEAPON_OBJECT_TO_PED - %s Ped [%s] has no weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetDebugName()))
|
|
{
|
|
if(pPed->GetPedConfigFlag(CPED_CONFIG_FLAG_InVehicle))
|
|
{
|
|
// Ensure current weapon is stored as a backup so we can restore it when getting out
|
|
pPed->GetWeaponManager()->SetBackupWeapon(pWeapon->GetWeaponHash());
|
|
pPed->GetWeaponManager()->EquipBestWeapon();
|
|
}
|
|
else if(pPed->GetIsSwimming() || pPed->GetPedResetFlag(CPED_RESET_FLAG_IsClimbing))
|
|
{
|
|
// Ensure current weapon is stored as a backup so we can restore it when getting out
|
|
pPed->GetWeaponManager()->SetBackupWeapon(pWeapon->GetWeaponHash());
|
|
}
|
|
else
|
|
{
|
|
if(pPed->GetWeaponManager()->EquipWeapon(pWeapon->GetWeaponHash(), -1, true))
|
|
{
|
|
CObject* pWeaponObject = pPed->GetWeaponManager()->GetEquippedWeaponObject();
|
|
if(pWeaponObject && pWeaponObject->GetWeapon() && pWeaponObject->GetWeapon()->GetFlashLightComponent() && pWeapon->GetFlashLightComponent())
|
|
{
|
|
pWeaponObject->GetWeapon()->GetFlashLightComponent()->TransferActiveness(pWeapon->GetFlashLightComponent());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CPedEquippedWeapon::DestroyObject(pObject, NULL);
|
|
}
|
|
}
|
|
|
|
bool CommandDoesWeaponTakeWeaponComponent(int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "DOES_WEAPON_TAKE_WEAPON_COMPONENT - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(TypeOfComponent);
|
|
if(scriptVerifyf(pComponentInfo, "DOES_WEAPON_TAKE_WEAPON_COMPONENT - %s pComponentInfo is NULL for component [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfComponent))
|
|
{
|
|
return pWeaponInfo->GetAttachPoint(pComponentInfo) != NULL;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int CommandGetWeaponObjectFromPed(int PedIndex, bool DoDeadCheck)
|
|
{
|
|
unsigned assertFlags = CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES;
|
|
if(!DoDeadCheck)
|
|
{
|
|
assertFlags = CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES_NO_DEAD_CHECK;
|
|
}
|
|
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, assertFlags);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:GET_WEAPON_OBJECT_FROM_PED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CObject* pWeaponObject = pPed->GetWeaponManager()->GetEquippedWeaponObject();
|
|
if(pWeaponObject)
|
|
{
|
|
CObject* pDroppedWeaponObject = pPed->GetWeaponManager()->DropWeapon(pPed->GetWeaponManager()->GetEquippedWeaponHash(), false, false);
|
|
|
|
if(scriptVerifyf(pDroppedWeaponObject, "%s:GET_WEAPON_OBJECT_FROM_PED - failed to get object from weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pDroppedWeaponObject->SetOwnedBy(ENTITY_OWNEDBY_SCRIPT);
|
|
CTheScripts::RegisterEntity(pDroppedWeaponObject);
|
|
return CTheScripts::GetGUIDFromEntity(*pDroppedWeaponObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CommandDropWeaponObjectOfPed(int PedIndex, bool DoDeadCheck)
|
|
{
|
|
unsigned assertFlags = CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES;
|
|
if (!DoDeadCheck)
|
|
{
|
|
assertFlags = CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES_NO_DEAD_CHECK;
|
|
}
|
|
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, assertFlags);
|
|
if (pPed && !pPed->IsNetworkClone())
|
|
{
|
|
if (scriptVerifyf(pPed->GetWeaponManager(), "%s:DROP_WEAPON_OBJECT_OF_PED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CObject* pWeaponObject = pPed->GetWeaponManager()->GetEquippedWeaponObject();
|
|
if (pWeaponObject)
|
|
{
|
|
CObject* pDroppedWeaponObject = pPed->GetWeaponManager()->DropWeapon(pPed->GetWeaponManager()->GetEquippedWeaponHash(), false, false, false, true);
|
|
pPed->GetWeaponManager()->GetWeaponSelector()->ClearSelectedWeapons();
|
|
|
|
if (scriptVerifyf(pDroppedWeaponObject, "%s:DROP_WEAPON_OBJECT_OF_PED - failed to get object from weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
if (pPed->GetNetworkObject())
|
|
{
|
|
SafeCast(CNetObjPed, pPed->GetNetworkObject())->SetHasDroppedWeapon(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CommandGiveLoadOutToPed(int PedIndex, int LoadOut)
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
CPedInventoryLoadOutManager::SetLoadOut(pPed, (u32)LoadOut);
|
|
}
|
|
}
|
|
|
|
void CommandSetLoadOutAlias(int OriginalLoadOut, int NewLoadOut)
|
|
{
|
|
CPedInventoryLoadOutManager::AddLoadOutAlias((u32)OriginalLoadOut, (u32)NewLoadOut);
|
|
}
|
|
|
|
void CommandClearLoadOutAlias(int LoadOut)
|
|
{
|
|
CPedInventoryLoadOutManager::RemoveLoadOutAlias((u32)LoadOut);
|
|
}
|
|
|
|
void CommandSetPedWeaponTintIndex(int PedIndex, int TypeOfWeapon, int TintIndex)
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_WEAPON_TINT_INDEX - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponItem, "%s:SET_PED_WEAPON_TINT_INDEX - ped does not have weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponItem->SetTintIndex((u8)TintIndex);
|
|
|
|
//! Update tint on active weapon.
|
|
if(pPed->GetWeaponManager() && pPed->GetWeaponManager()->GetEquippedWeapon())
|
|
{
|
|
if(pPed->GetWeaponManager()->GetEquippedWeapon()->GetWeaponHash() == (u32)TypeOfWeapon)
|
|
{
|
|
pPed->GetWeaponManager()->GetEquippedWeapon()->UpdateShaderVariables((u8)TintIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetPedWeaponTintIndex(int PedIndex, int TypeOfWeapon)
|
|
{
|
|
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:GET_PED_WEAPON_TINT_INDEX - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponItem, "%s:GET_PED_WEAPON_TINT_INDEX - ped does not have weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponItem->GetTintIndex();
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CommandSetPedWeaponComponentTintIndex(int PedIndex, int TypeOfWeapon, int TypeOfComponent, int TintIndex)
|
|
{
|
|
if (scriptVerifyf(TintIndex >= 0, "%s:SET_PED_WEAPON_COMPONENT_TINT_INDEX - Invalid tint index [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TintIndex))
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if (pPed)
|
|
{
|
|
if (scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_WEAPON_COMPONENT_TINT_INDEX - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if (scriptVerifyf(pWeaponItem, "%s:SET_PED_WEAPON_COMPONENT_TINT_INDEX - ped does not have weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
// Update tint on weapon item
|
|
if (pWeaponItem->GetComponents())
|
|
{
|
|
const CWeaponItem::Components& components = *pWeaponItem->GetComponents();
|
|
for (s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if (components[i].pComponentInfo->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
pWeaponItem->SetComponentTintIndex(i, (u8)TintIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update component tint on active weapon
|
|
if (pPed->GetWeaponManager())
|
|
{
|
|
CWeapon* pWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
if (pWeapon && pWeapon->GetWeaponHash() == (u32)TypeOfWeapon)
|
|
{
|
|
const CWeapon::Components& components = pWeapon->GetComponents();
|
|
for (s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if (components[i]->GetInfo()->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
components[i]->UpdateShaderVariables((u8)TintIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetPedWeaponComponentTintIndex(int PedIndex, int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:GET_PED_WEAPON_COMPONENT_TINT_INDEX - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
const CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponItem, "%s:GET_PED_WEAPON_COMPONENT_TINT_INDEX - ped does not have weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
if(pWeaponItem->GetComponents())
|
|
{
|
|
const CWeaponItem::Components& components = *pWeaponItem->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(components[i].pComponentInfo->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
return components[i].m_uTintIndex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CommandSetPedWeaponCamoIndex(int PedIndex, int TypeOfWeapon, int CamoIdx)
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:SET_PED_WEAPON_CAMO_INDEX - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponItem, "%s:SET_PED_WEAPON_CAMO_INDEX - ped does not have weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
if(pPed->GetWeaponManager() && pPed->GetWeaponManager()->GetEquippedWeapon())
|
|
{
|
|
if(pPed->GetWeaponManager()->GetEquippedWeapon()->GetWeaponHash() == (u32)TypeOfWeapon)
|
|
{
|
|
pPed->GetWeaponManager()->GetEquippedWeapon()->SetCamoDiffuseTexIdx(CamoIdx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetPedWeaponCamoIndex(int PedIndex, int TypeOfWeapon)
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetInventory(), "%s:GET_PED_WEAPON_CAMO_INDEX - ped requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeaponItem* pWeaponItem = pPed->GetInventory()->GetWeapon(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponItem, "%s:GET_PED_WEAPON_CAMO_INDEX - ped does not have weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
if(pPed->GetWeaponManager() && pPed->GetWeaponManager()->GetEquippedWeapon())
|
|
{
|
|
if(pPed->GetWeaponManager()->GetEquippedWeapon()->GetWeaponHash() == (u32)TypeOfWeapon)
|
|
{
|
|
return pPed->GetWeaponManager()->GetEquippedWeapon()->GetCamoDiffuseTexIdx();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void CommandSetWeaponObjectTintIndex(int ObjectIndex, int TintIndex)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "SET_WEAPON_OBJECT_TINT_INDEX - %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
pWeapon->UpdateShaderVariables((u8)TintIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetWeaponObjectTintIndex(int ObjectIndex)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "GET_WEAPON_OBJECT_TINT_INDEX - %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
return pWeapon->GetTintIndex();
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CommandSetWeaponObjectComponentTintIndex(int ObjectIndex, int TypeOfComponent, int TintIndex)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX - %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
if (pWeapon)
|
|
{
|
|
const CWeapon::Components& components = pWeapon->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(components[i]->GetInfo()->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
components[i]->UpdateShaderVariables((u8)TintIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetWeaponObjectComponentTintIndex(int ObjectIndex, int TypeOfComponent)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX - %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
if (pWeapon)
|
|
{
|
|
const CWeapon::Components& components = pWeapon->GetComponents();
|
|
for(s32 i = 0; i < components.GetCount(); i++)
|
|
{
|
|
if(components[i]->GetInfo()->GetHash() == (u32)TypeOfComponent)
|
|
{
|
|
return components[i]->GetTintIndex();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int CommandGetWeaponTintCount(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_TINT_COUNT - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetSpecValuesCount();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CommandSetWeaponObjectCamoIndex(int ObjectIndex, int CamoIdx)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "SET_WEAPON_OBJECT_CAMO_INDEX - %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
pWeapon->SetCamoDiffuseTexIdx(CamoIdx);
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetWeaponObjectCamoIndex(int ObjectIndex)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "GET_WEAPON_OBJECT_CAMO_INDEX - %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
return pWeapon->GetCamoDiffuseTexIdx();
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
bool CommandGetWeaponHudStats(int TypeOfWeapon, scrWeaponHudValues* out_Values)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_HUD_STATS - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
out_Values->HudDamage.Int = pWeaponInfo->GetHudDamage();
|
|
out_Values->HudSpeed.Int = pWeaponInfo->GetHudSpeed();
|
|
out_Values->HudCapacity.Int = pWeaponInfo->GetHudCapacity();
|
|
out_Values->HudAccuracy.Int = pWeaponInfo->GetHudAccuracy();
|
|
out_Values->HudRange.Int = pWeaponInfo->GetHudRange();
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CommandGetWeaponComponentHudStats(int TypeOfComponent, scrWeaponHudValues* out_Values)
|
|
{
|
|
if(TypeOfComponent != 0)
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(TypeOfComponent);
|
|
if(scriptVerifyf(pComponentInfo, "Weapon component hash [%d] does not exist in data", TypeOfComponent))
|
|
{
|
|
out_Values->HudDamage.Int = pComponentInfo->GetHudDamage();
|
|
out_Values->HudSpeed.Int = pComponentInfo->GetHudSpeed();
|
|
out_Values->HudCapacity.Int = pComponentInfo->GetHudCapacity();
|
|
out_Values->HudAccuracy.Int = pComponentInfo->GetHudAccuracy();
|
|
out_Values->HudRange.Int = pComponentInfo->GetHudRange();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
float CommandGetWeaponDamage(int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_DAMAGE - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
float fDamage = pWeaponInfo->GetDamage();
|
|
|
|
if(TypeOfComponent != 0)
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(TypeOfComponent);
|
|
if(scriptVerifyf(pComponentInfo, "Weapon component hash [%d] does not exist in data", TypeOfComponent))
|
|
{
|
|
if(pComponentInfo->GetDamageModifier())
|
|
{
|
|
pComponentInfo->GetDamageModifier()->ModifyDamage(fDamage);
|
|
}
|
|
}
|
|
}
|
|
return fDamage;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
int CommandGetWeaponClipSize(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_CLIP_SIZE - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetClipSize();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
float CommandGetWeaponTimeBetweenShots(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_TIME_BETWEEN_SHOTS - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetTimeBetweenShots();
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
float CommandGetWeaponAccuracy(int TypeOfWeapon, int TypeOfComponent)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_ACCURACY - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
float fAccuracySpread = pWeaponInfo->GetAccuracySpread();
|
|
if(TypeOfComponent != 0)
|
|
{
|
|
const CWeaponComponentInfo* pComponentInfo = CWeaponComponentManager::GetInfo(TypeOfComponent);
|
|
if(scriptVerifyf(pComponentInfo, "Weapon component hash [%d] does not exist in data", TypeOfComponent))
|
|
{
|
|
if(pComponentInfo->GetAccuracyModifier())
|
|
{
|
|
sWeaponAccuracy weaponAccuracy;
|
|
weaponAccuracy.fAccuracy = fAccuracySpread;
|
|
pComponentInfo->GetAccuracyModifier()->ModifyAccuracy(weaponAccuracy);
|
|
fAccuracySpread = weaponAccuracy.fAccuracy;
|
|
}
|
|
}
|
|
}
|
|
return fAccuracySpread;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
void CommandSetPedChanceOfFiringBlanks(int PedIndex, float ChanceOfFiringBlanksMin, float ChanceOfFiringBlanksMax)
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:SET_PED_CHANCE_OF_FIRING_BLANKS - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
pPed->GetWeaponManager()->SetChanceToFireBlanks(ChanceOfFiringBlanksMin, ChanceOfFiringBlanksMax);
|
|
}
|
|
}
|
|
}
|
|
|
|
s32 CommandSetPedShootOrdnanceWeapon( int PedIndex, float fOverrideLifeTime )
|
|
{
|
|
s32 ReturnObjectIndex = NULL_IN_SCRIPTING_LANGUAGE;
|
|
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if( scriptVerifyf( pPed->GetWeaponManager(), "%s:SET_PED_SHOOT_ORDNANCE_WEAPON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
CPedEquippedWeapon* pPedEquippedWeapon = pPed->GetWeaponManager()->GetPedEquippedWeapon();
|
|
scriptAssertf( pPedEquippedWeapon, "%s:SET_PED_SHOOT_ORDNANCE_WEAPON - Invalid equipped weapon.", CTheScripts::GetCurrentScriptNameAndProgramCounter());
|
|
|
|
CProjectile* pProjectileObject = pPedEquippedWeapon->GetProjectileOrdnance();
|
|
if( pProjectileObject )
|
|
{
|
|
// Cache off the ordnance
|
|
ReturnObjectIndex = CTheScripts::GetGUIDFromEntity( *pProjectileObject );
|
|
|
|
CWeapon* pEquippedWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
CObject* pWeaponObject = pPed->GetWeaponManager()->GetEquippedWeaponObject();
|
|
if( scriptVerifyf( pEquippedWeapon && pWeaponObject, "%s:SET_PED_SHOOT_ORDNANCE_WEAPON - ped requires an equipped weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
Matrix34 matWeapon;
|
|
if( pEquippedWeapon->GetWeaponModelInfo()->GetBoneIndex( WEAPON_MUZZLE ) != -1 )
|
|
pWeaponObject->GetGlobalMtx( pEquippedWeapon->GetWeaponModelInfo()->GetBoneIndex( WEAPON_MUZZLE ), matWeapon );
|
|
else
|
|
pWeaponObject->GetMatrixCopy( matWeapon );
|
|
|
|
CWeapon::sFireParams params( pPed, matWeapon, NULL, NULL );
|
|
params.bScriptControlled = true;
|
|
params.fOverrideLifeTime = fOverrideLifeTime;
|
|
pEquippedWeapon->Fire( params );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ReturnObjectIndex;
|
|
}
|
|
|
|
void CommandRequestWeaponHighDetailModel(int ObjectIndex)
|
|
{
|
|
CObject* pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ObjectIndex);
|
|
if(pObject)
|
|
{
|
|
if(scriptVerifyf(pObject->GetWeapon(), "REQUEST_WEAPON_HIGH_DETAIL_MODEL- %s Object [%s] has no weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pObject->GetModelName()))
|
|
{
|
|
CWeapon* pWeapon = pObject->GetWeapon();
|
|
pWeapon->RequestHdAssets();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandSetWeaponDamageModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "SET_WEAPON_DAMAGE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetWeaponDamageModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetWeaponDamageModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_DAMAGE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetWeaponDamageModifier();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetWeaponFallOffRangeModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "SET_WEAPON_FALL_OFF_RANGE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetDamageFallOffRangeModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetWeaponFallOffRangeModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_WEAPON_FALL_OFF_RANGE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetDamageFallOffRangeModifier();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetWeaponFallOffDamageModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if (scriptVerifyf(pWeaponInfo, "SET_WEAPON_FALL_OFF_DAMAGE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetDamageFallOffTransientModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetWeaponFallOffDamageModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (scriptVerifyf(pWeaponInfo, "GET_WEAPON_FALL_OFF_DAMAGE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetDamageFallOffTransientModifier();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetWeaponAoEModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if (scriptVerifyf(pWeaponInfo, "SET_WEAPON_AOE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetAoEModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetWeaponAoEModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (scriptVerifyf(pWeaponInfo, "GET_WEAPON_AOE_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetAoEModifier();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetWeaponEffectDurationModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if (scriptVerifyf(pWeaponInfo, "SET_WEAPON_EFFECT_DURATION_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetEffectDurationModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetWeaponEffectDurationModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (scriptVerifyf(pWeaponInfo, "GET_WEAPON_EFFECT_DURATION_MODIFIER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetEffectDurationModifier();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetRecoilAccuracyToAllowHeadShotPlayerModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "SET_RECOIL_ACCURACY_TO_ALLOW_HEADSHOT_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetRecoilAccuracyToAllowHeadShotPlayerModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetRecoilAccuracyToAllowHeadShotPlayerModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_RECOIL_ACCURACY_TO_ALLOW_HEADSHOT_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetRecoilAccuracyToAllowHeadShotPlayerModifier();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetMinHeadShotDistancePlayerModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "SET_MIN_HEADSHOT_DISTANCE_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetMinHeadShotDistancePlayerModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetMinHeadShotDistancePlayerModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_MIN_HEADSHOT_DISTANCE_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetMinHeadShotDistancePlayerModifier();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetMaxHeadShotDistancePlayerModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "SET_MAX_HEADSHOT_DISTANCE_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetMaxHeadShotDistancePlayerModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetMaxHeadShotDistancePlayerModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_MAX_HEADSHOT_DISTANCE_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetMaxHeadShotDistancePlayer();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CommandSetHeadShotDamageModifierPlayerModifier(int TypeOfWeapon, float NewModifier)
|
|
{
|
|
CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoNonConst<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "SET_HEADSHOT_DAMAGE_MODIFIER_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
pWeaponInfo->SetHeadShotDamageModifierPlayerModifier(NewModifier);
|
|
}
|
|
}
|
|
|
|
float CommandGetHeadShotDamageModifierPlayerModifier(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if(scriptVerifyf(pWeaponInfo, "GET_HEADSHOT_DAMAGE_MODIFIER_PLAYER - %s pWeaponInfo is NULL for weapon [%d]", CTheScripts::GetCurrentScriptNameAndProgramCounter(), TypeOfWeapon))
|
|
{
|
|
return pWeaponInfo->GetHeadShotDamageModifierPlayer();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
bool CommandIsPedCurrentWeaponSilenced(int PedIndex)
|
|
{
|
|
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES_NO_DEAD_CHECK);
|
|
if(pPed)
|
|
{
|
|
if( scriptVerifyf( pPed->GetWeaponManager(), "%s:IS_PED_CURRENT_WEAPON_SILENCED - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter() ) )
|
|
{
|
|
const CWeapon* pEquippedWeapon = pPed->GetWeaponManager()->GetEquippedWeapon();
|
|
if(pEquippedWeapon)
|
|
{
|
|
return pEquippedWeapon->GetIsSilenced();
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CommandIsFlashLightOn(int PedIndex)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
CPedWeaponManager* pWeaponMgr = pPed->GetWeaponManager();
|
|
if(scriptVerifyf(pWeaponMgr, "%s: IS_FLASH_LIGHT_ON - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeapon* pWeapon = pWeaponMgr->GetEquippedWeapon();
|
|
if(pWeapon && pWeapon->GetFlashLightComponent())
|
|
{
|
|
return pWeapon->GetFlashLightComponent()->GetActive();
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CommandSetFlashlightFadeDistance(float distance)
|
|
{
|
|
CWeaponComponentFlashLight::SetFlashlightFadeDistance(distance);
|
|
}
|
|
|
|
void CommandSetFlashlightActiveHistory(int PedIndex, bool bActive)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
CPedWeaponManager* pWeaponMgr = pPed->GetWeaponManager();
|
|
if(scriptVerifyf(pWeaponMgr, "%s: SET_FLASH_LIGHT_ACTIVE_HISTORY - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
|
|
{
|
|
CWeapon* pWeapon = pWeaponMgr->GetEquippedWeapon();
|
|
if(pWeapon && pWeapon->GetFlashLightComponent())
|
|
{
|
|
pWeapon->GetFlashLightComponent()->SetActiveHistory(bActive);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandWeaponAnimationOverride(int PedIndex, int WeaponAnimationOverride)
|
|
{
|
|
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
if(scriptVerifyf( WeaponAnimationOverride == 0 || CWeaponAnimationsManager::GetInstance().DoesWeaponAnimationSetForHashExist(WeaponAnimationOverride), "WeaponAnimationOverride doesn't exist"))
|
|
{
|
|
pPed->SetOverrideWeaponAnimations(WeaponAnimationOverride);
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandGetWeaponDamageType(int TypeOfWeapon)
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(TypeOfWeapon);
|
|
if (pWeaponInfo)
|
|
{
|
|
return pWeaponInfo->GetDamageType();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CommandSetEqippedWeaponStartSpinningAtFullSpeed(int PedIndex)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
if(pPed)
|
|
{
|
|
CPedWeaponManager* pWeaponManager = pPed->GetWeaponManager();
|
|
if(pWeaponManager)
|
|
{
|
|
CWeapon* pEquippedWeapon = pWeaponManager->GetEquippedWeapon();
|
|
if(pEquippedWeapon)
|
|
{
|
|
pEquippedWeapon->SetNoSpinUp(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CommandCanUseWeaponOnParachute(int weaponHash)
|
|
{
|
|
if(SCRIPT_VERIFY( weaponHash != 0, "GET_WEAPONTYPE_MODEL - Weapon hash is invalid"))
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(weaponHash);
|
|
if(scriptVerifyf(pWeaponInfo, "Weapon hash [%d] does not exist in data", weaponHash))
|
|
{
|
|
static atHashWithStringNotFinal s_ParaDriveByName("DRIVEBY_PARACHUTE", 0x9e643cb0);
|
|
const CVehicleDriveByInfo* pDrivebyInfo = CVehicleMetadataMgr::GetVehicleDriveByInfo(s_ParaDriveByName.GetHash());
|
|
if(pDrivebyInfo && !pWeaponInfo->GetNotAllowedForDriveby())
|
|
{
|
|
return pDrivebyInfo->CanUseWeaponGroup(pWeaponInfo->GetGroup()) || pDrivebyInfo->CanUseWeaponType(weaponHash);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int CommandCreateAirDefenceSphere(const scrVector &scrPosition, const float fRadius, const scrVector &scrWeaponPosition, int WeaponHash)
|
|
{
|
|
Vec3V vPosition = Vec3V(scrPosition);
|
|
Vec3V vWeaponPosition = Vec3V(scrWeaponPosition);
|
|
int uZoneIdx = CAirDefenceManager::CreateAirDefenceSphere(vPosition, fRadius, vWeaponPosition, WeaponHash);
|
|
return uZoneIdx;
|
|
}
|
|
|
|
int CommandCreateAirDefenceAngledArea(const scrVector &scrCoordA, const scrVector &scrCoordB, const float fWidth, const scrVector &scrWeaponPosition, int WeaponHash)
|
|
{
|
|
// Copy vectors
|
|
Vec3V vA = Vec3V(scrCoordA);
|
|
Vec3V vB = Vec3V(scrCoordB);
|
|
|
|
// Construct transform matrix
|
|
Vec3V vAToB = vB - vA;
|
|
Vec3V vUp(0.0f, 0.0f, 1.0f);
|
|
Vec3V vRight = Cross(vAToB, vUp);
|
|
vRight = Normalize(vRight);
|
|
Vec3V vForward = Cross(vUp, vRight);
|
|
vForward = Normalize(vForward);
|
|
Vec3V vPosition = vA + vAToB * ScalarV(0.5f);
|
|
Mat34V mtx(vRight, vForward, vUp, vPosition);
|
|
|
|
// Construct min / max points
|
|
float fHalfWidth = fWidth * 0.5f;
|
|
Vec3V vMax = vB + vRight * ScalarV(fHalfWidth);
|
|
vMax = UnTransformOrtho(mtx, vMax);
|
|
Vec3V vMin = -vMax;
|
|
|
|
Vec3V vWeaponPosition = Vec3V(scrWeaponPosition);
|
|
int uZoneIdx = CAirDefenceManager::CreateAirDefenceArea(vMin, vMax, mtx, vWeaponPosition, WeaponHash);
|
|
return uZoneIdx;
|
|
}
|
|
|
|
|
|
bool CommandRemoveAirDefenceSphere(int iZoneIndex)
|
|
{
|
|
if (CAirDefenceManager::DeleteAirDefenceZone((u8)iZoneIndex))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CommandRemoveAirDefenceSpheresInteresectingPosition(const scrVector &scrPosition)
|
|
{
|
|
Vec3V vPosition = Vec3V(scrPosition);
|
|
if (CAirDefenceManager::DeleteAirDefenceZonesInteresectingPosition(vPosition))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CommandRemoveAllAirDefenceSpheres()
|
|
{
|
|
CAirDefenceManager::ResetAllAirDefenceZones();
|
|
}
|
|
|
|
|
|
void CommandSetPlayerTargettableForAllAirDefenceSpheres(int PlayerIndex, bool bTargettable)
|
|
{
|
|
if (PlayerIndex != -1)
|
|
{
|
|
CAirDefenceManager::SetPlayerTargetableForAllZones(PlayerIndex, bTargettable);
|
|
}
|
|
}
|
|
|
|
void CommandSetPlayerTargettableForAirDefenceSphere(int PlayerIndex, int ZoneIndex, bool bTargettable)
|
|
{
|
|
if (PlayerIndex != -1)
|
|
{
|
|
CAirDefenceZone *pDefZone = CAirDefenceManager::GetAirDefenceZone((u8)ZoneIndex);
|
|
if (scriptVerifyf(pDefZone, "SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE: Invalid sphere - SphereIndex: %d", ZoneIndex))
|
|
{
|
|
pDefZone->SetPlayerIsTargettable(PlayerIndex, bTargettable);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandResetPlayerTargettableFlagsForAllAirDefenceSpheres()
|
|
{
|
|
CAirDefenceManager::ResetPlayerTargetableFlagsForAllZones();
|
|
}
|
|
|
|
void CommandResetPlayetTargettableFlagsForAirDefenceSphere(int ZoneIndex)
|
|
{
|
|
CAirDefenceManager::ResetPlayetTargetableFlagsForZone((u8)ZoneIndex);
|
|
}
|
|
|
|
bool CommandIsAirDefenceSphereInArea(const scrVector &scrPosition, const float fRadius, int &ZoneIndex)
|
|
{
|
|
ZoneIndex = 0;
|
|
Vec3V vPosition = Vec3V(scrPosition);
|
|
u8 uUpdatedZoneIndex = 0;
|
|
if (CAirDefenceManager::IsDefenceZoneInArea(vPosition, fRadius, uUpdatedZoneIndex))
|
|
{
|
|
ZoneIndex = (int)uUpdatedZoneIndex;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CommandFireAirDefenceSphereWeaponAtPosition(int ZoneIndex, const scrVector &scrPosition)
|
|
{
|
|
Vec3V vTargetPosition = Vec3V(scrPosition);
|
|
CAirDefenceZone *pDefZone = CAirDefenceManager::GetAirDefenceZone((u8)ZoneIndex);
|
|
if (scriptVerifyf(pDefZone, "FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION: Invalid sphere - SphereIndex: %d", ZoneIndex))
|
|
{
|
|
if(scriptVerifyf(pDefZone->GetWeaponHash() != 0, "FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION: Sphere was not set up with a weapon hash - SphereIndex: %d", ZoneIndex))
|
|
{
|
|
pDefZone->FireWeaponAtPosition(vTargetPosition, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CommandDoesAirDefenceSphereExist(int ZoneIndex)
|
|
{
|
|
CAirDefenceZone *pDefZone = CAirDefenceManager::GetAirDefenceZone((u8)ZoneIndex);
|
|
if (pDefZone)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CommandSetCanPedSelectIventoryWeapon(int PedIndex, int WeaponHash, bool bCanSelect)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
CPedInventory* pPedInventory = pPed->GetInventory();
|
|
if(scriptVerifyf(pPedInventory, "%s:SET_CAN_PED_SELECT_INVENTORY_WEAPON - %s[%p] requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetModelName(), pPed))
|
|
{
|
|
CWeaponItem* pWeaponItem = pPedInventory->GetWeapon(WeaponHash);
|
|
|
|
if (scriptVerifyf(pWeaponItem, "%s:SET_CAN_PED_SELECT_INVENTORY_WEAPON - Could not find weapon (hash - %i) in %s[%p] inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponHash, pPed->GetModelName(), pPed))
|
|
{
|
|
pWeaponItem->SetCanSelect(bCanSelect);
|
|
weaponDebugf3("%s:SET_CAN_PED_SELECT_INVENTORY_WEAPON: ped - %s[%p], weaponHash - %i, canSelect - %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetModelName(), pPed, WeaponHash, bCanSelect ? "true" : "false");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandSetCanPedSelectAllWeapons(int PedIndex, bool bCanSelect)
|
|
{
|
|
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
|
|
|
|
if(pPed)
|
|
{
|
|
CPedInventory* pPedInventory = pPed->GetInventory();
|
|
if(scriptVerifyf(pPedInventory, "%s:SET_CAN_PED_SELECT_ALL_WEAPONS - %s[%p] requires an inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetModelName(), pPed))
|
|
{
|
|
CWeaponItemRepository& rWeaponRepository = pPedInventory->GetWeaponRepository();
|
|
for(int i=0; i < rWeaponRepository.GetItemCount(); i++)
|
|
{
|
|
CWeaponItem* pWeaponItem = rWeaponRepository.GetItemByIndex(i);
|
|
if (pWeaponItem)
|
|
{
|
|
pWeaponItem->SetCanSelect(bCanSelect);
|
|
weaponDebugf3("%s:SET_CAN_PED_SELECT_ALL_WEAPONS: ped - %s[%p], weapon - %s, canSelect - %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetModelName(), pPed, pWeaponItem->GetInfo() ? pWeaponItem->GetInfo()->GetName() : "", bCanSelect ? "true" : "false");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CommandGetWeaponHasNonLethalTag(int weaponHash)
|
|
{
|
|
if (SCRIPT_VERIFY(weaponHash != 0, "GET_WEAPON_HAS_NON_LETHAL_TAG - Weapon hash is invalid"))
|
|
{
|
|
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(weaponHash);
|
|
|
|
if (scriptVerifyf(pWeaponInfo, "GET_WEAPON_HAS_NON_LETHAL_TAG - Weapon hash [%d] does not exist in data", weaponHash))
|
|
{
|
|
return pWeaponInfo->GetIsNonLethal();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// name: SetupScriptCommands
|
|
// description: Setup weapons script commands
|
|
void SetupScriptCommands()
|
|
{
|
|
SCR_REGISTER_SECURE(ENABLE_LASER_SIGHT_RENDERING,0xe05dc71741b614fb, CommandEnableLaserSightRendering);
|
|
|
|
SCR_REGISTER_SECURE(GET_WEAPON_COMPONENT_TYPE_MODEL,0x2597f123290b0413, CommandGetWeaponComponentTypeModel);
|
|
SCR_REGISTER_SECURE(GET_WEAPONTYPE_MODEL,0xb8dee91181c30e65, CommandGetWeaponTypeModel);
|
|
SCR_REGISTER_SECURE(GET_WEAPONTYPE_SLOT,0xc5ede22c3d2885b3, CommandGetWeaponTypeSlot);
|
|
SCR_REGISTER_SECURE(GET_WEAPONTYPE_GROUP,0x7f4cb90bca531a70, CommandGetWeaponTypeGroup);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT,0xb02e6513201cffba, CommandGetWeaponComponentVariantExtraCount);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL,0xdcd1cf170306e130, CommandGetWeaponComponentVariantExtraModel);
|
|
|
|
SCR_REGISTER_SECURE(SET_CURRENT_PED_WEAPON,0x202b28feabec4034, CommandSetCurrentPedWeapon);
|
|
SCR_REGISTER_SECURE(GET_CURRENT_PED_WEAPON,0xa7e29842fa438ed6, CommandGetCurrentPedWeapon);
|
|
SCR_REGISTER_SECURE(GET_CURRENT_PED_WEAPON_ENTITY_INDEX,0x4d03373543a78098, CommandGetCurrentPedWeaponEntityIndex);
|
|
SCR_REGISTER_SECURE(GET_BEST_PED_WEAPON,0x4eb626d21abb5bae, CommandGetBestPedWeapon);
|
|
SCR_REGISTER_SECURE(SET_CURRENT_PED_VEHICLE_WEAPON,0x922ac1d1e4ad7864, CommandSetCurrentPedVehicleWeapon);
|
|
SCR_REGISTER_SECURE(GET_CURRENT_PED_VEHICLE_WEAPON,0x0cc0416f24be03ff, CommandGetCurrentPedVehicleWeapon);
|
|
SCR_REGISTER_SECURE(SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY,0x983daefb042809e8, CommandSetCycleVehicleWeaponsOnly);
|
|
SCR_REGISTER_SECURE(IS_PED_ARMED,0x5007a91d57c39ffc, CommandIsPedArmed);
|
|
|
|
SCR_REGISTER_SECURE(IS_WEAPON_VALID,0x072699bd07af0086, CommandIsWeaponValid);
|
|
SCR_REGISTER_SECURE(HAS_PED_GOT_WEAPON,0x8fea2e94638f9767, CommandHasPedGotWeapon);
|
|
SCR_REGISTER_SECURE(IS_PED_WEAPON_READY_TO_SHOOT,0xc9ddce46bcbb3f06, CommandIsPedWeaponReadyToShoot);
|
|
SCR_REGISTER_SECURE(GET_PED_WEAPONTYPE_IN_SLOT,0xcb497f652acb2dd3, CommandGetPedWeaponTypeInSlot);
|
|
SCR_REGISTER_SECURE(GET_AMMO_IN_PED_WEAPON,0x1f741abe25b3cdd3, CommandGetAmmoInPedWeapon);
|
|
SCR_REGISTER_SECURE(ADD_AMMO_TO_PED,0x4f692b4cc67a70bc, CommandAddAmmoToPed);
|
|
SCR_REGISTER_SECURE(SET_PED_AMMO,0xca8f055643a07c74, CommandSetPedAmmo);
|
|
SCR_REGISTER_SECURE(SET_PED_INFINITE_AMMO,0x73ac05050f54f1e0, CommandSetPedInfiniteAmmo);
|
|
SCR_REGISTER_SECURE(SET_PED_INFINITE_AMMO_CLIP,0xb5ad1b3d21ec1aa1, CommandSetPedInfiniteAmmoClip);
|
|
SCR_REGISTER_SECURE(SET_PED_STUN_GUN_FINITE_AMMO,0x5af8598f3b8dd63d, CommandSetPedStunGunFiniteAmmo);
|
|
SCR_REGISTER_SECURE(GIVE_WEAPON_TO_PED,0x9521fb98db6ddf50, CommandGiveWeaponToPed);
|
|
SCR_REGISTER_SECURE(GIVE_DELAYED_WEAPON_TO_PED,0x5399a284d9fad3bd, CommandGiveDelayedWeaponToPed);
|
|
SCR_REGISTER_SECURE(REMOVE_ALL_PED_WEAPONS,0x70d9ec5af67d79c4, CommandRemoveAllPedWeapons);
|
|
SCR_REGISTER_SECURE(REMOVE_WEAPON_FROM_PED,0xe002dfd518bf86a7, CommandRemoveWeaponFromPed);
|
|
SCR_REGISTER_SECURE(HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE,0x4f1e6a84bc157fa0, CommandHidePedWeaponForScriptedCutscene);
|
|
SCR_REGISTER_SECURE(SET_PED_CURRENT_WEAPON_VISIBLE,0x882a3682867542aa, CommandSetPedCurrentWeaponVisible);
|
|
SCR_REGISTER_SECURE(SET_PED_DROPS_WEAPONS_WHEN_DEAD,0x671d9a1f3d47d0de, CommandSetPedDropsWeaponsWhenDead);
|
|
SCR_REGISTER_SECURE(HAS_PED_BEEN_DAMAGED_BY_WEAPON,0x6799f7dd0261990e, CommandHasPedBeenDamagedByWeapon);
|
|
SCR_REGISTER_SECURE(CLEAR_PED_LAST_WEAPON_DAMAGE,0xe095496a833d555c, CommandClearPedLastWeaponDamage);
|
|
|
|
SCR_REGISTER_SECURE(HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON,0xeef1a3c0e56fc8ff, CommandHasEntityBeenDamagedByWeapon);
|
|
SCR_REGISTER_SECURE(CLEAR_ENTITY_LAST_WEAPON_DAMAGE,0x2ad4bd9956c8aad7, CommandClearEntityLastWeaponDamage);
|
|
SCR_REGISTER_SECURE(SET_PED_DROPS_WEAPON,0xa6d4fbb3b47cf11e, CommandPedDropWeapon);
|
|
SCR_REGISTER_SECURE(SET_PED_DROPS_INVENTORY_WEAPON,0x35e8b97ba540a71f, CommandPedDropsInventoryWeapon);
|
|
SCR_REGISTER_SECURE(GET_MAX_AMMO_IN_CLIP,0x3fc10ba7b76fe8ba, CommandGetMaxAmmoInClip);
|
|
SCR_REGISTER_SECURE(GET_AMMO_IN_CLIP,0x49d5a28b919b07c0, CommandGetAmmoInClip);
|
|
SCR_REGISTER_SECURE(SET_AMMO_IN_CLIP,0x1e0ed6750db74e70, CommandSetAmmoInClip);
|
|
SCR_REGISTER_SECURE(GET_MAX_AMMO,0x6019be7548b68c4b, CommandGetMaxAmmo);
|
|
SCR_REGISTER_SECURE(GET_MAX_AMMO_BY_TYPE,0x5b75073e91a0aef6, CommandGetMaxAmmoByType);
|
|
|
|
SCR_REGISTER_SECURE(ADD_PED_AMMO_BY_TYPE,0xfaf8b712245b6bf6, CommandAddPedAmmoByType);
|
|
SCR_REGISTER_SECURE(SET_PED_AMMO_BY_TYPE,0xb003193c68661c8d, CommandSetPedAmmoByType);
|
|
SCR_REGISTER_SECURE(GET_PED_AMMO_BY_TYPE,0x4a88c4acac824897, CommandGetPedAmmoByType);
|
|
|
|
SCR_REGISTER_SECURE(SET_PED_AMMO_TO_DROP,0xbeb9849370cc0abe, CommandSetPedAmmoToDrop);
|
|
SCR_REGISTER_SECURE(SET_PICKUP_AMMO_AMOUNT_SCALER,0xed8e9ca97c15c21d, CommandSetPickupAmmoAmountScaler);
|
|
|
|
SCR_REGISTER_SECURE(GET_PED_AMMO_TYPE_FROM_WEAPON,0x5d3596c624f0c4ac, CommandGetPedAmmoTypeFromWeapon);
|
|
SCR_REGISTER_SECURE(GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON,0x589b5b25edf4e89c, CommandGetPedOriginalAmmoTypeFromWeapon);
|
|
|
|
SCR_REGISTER_SECURE(GET_PED_LAST_WEAPON_IMPACT_COORD,0x2ef467a4dca81d5a, CommandGetPedLastWeaponImpactCoord);
|
|
|
|
SCR_REGISTER_SECURE(SET_PED_GADGET,0x777180e634735829, CommandSetPedGadget);
|
|
SCR_REGISTER_SECURE(GET_IS_PED_GADGET_EQUIPPED,0x8de48073046d4cf0, CommandGetIsPedGadgetEquipped);
|
|
SCR_REGISTER_SECURE(GET_SELECTED_PED_WEAPON,0x65141ccb0a6f7ea4, CommandGetSelectedPedWeapon);
|
|
|
|
SCR_REGISTER_SECURE(EXPLODE_PROJECTILES,0x8c7d915965382c47, CommandExplodeProjectiles);
|
|
SCR_REGISTER_SECURE(REMOVE_ALL_PROJECTILES_OF_TYPE,0xa968e928ca6f0a96, CommandRemoveAllProjectilesOfType);
|
|
SCR_REGISTER_UNUSED(ACTIVATE_DETONATOR,0x42c916a10522b15f, CommandActivateDetonator);
|
|
SCR_REGISTER_UNUSED(GET_IS_DETONATOR_FIRED,0xb4cdf0805f86df21, CommandGetIsDetonatorFired);
|
|
SCR_REGISTER_UNUSED(GET_IS_STICKY_CAM_VIEWER_FIRED,0x68cf1e9fee40721e, CommandGetIsStickyCamViewerFired);
|
|
SCR_REGISTER_SECURE(GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON,0xaec78423999efe49, CommandGetLockOnDistanceOfCurrentPedWeapon);
|
|
SCR_REGISTER_SECURE(GET_MAX_RANGE_OF_CURRENT_PED_WEAPON,0x6658b2555bca5bdf, CommandGetMaxRangeOfCurrentPedWeapon);
|
|
SCR_REGISTER_SECURE(HAS_VEHICLE_GOT_PROJECTILE_ATTACHED,0xbc0cfdf47c99d84b, CommandHasVehicleGotProjectileAttached);
|
|
|
|
SCR_REGISTER_SECURE(GIVE_WEAPON_COMPONENT_TO_PED,0x130c7a0e5945e494, CommandGiveWeaponComponentToPed);
|
|
SCR_REGISTER_SECURE(REMOVE_WEAPON_COMPONENT_FROM_PED,0xdead024b4d0717f8, CommandRemoveWeaponComponentFromPed);
|
|
SCR_REGISTER_SECURE(HAS_PED_GOT_WEAPON_COMPONENT,0x54b42dec4cab3d41, CommandHasPedGotWeaponComponent);
|
|
SCR_REGISTER_SECURE(IS_PED_WEAPON_COMPONENT_ACTIVE,0x5c89acc6e6cf4148, CommandIsPedWeaponComponentActive);
|
|
|
|
SCR_REGISTER_UNUSED(GET_PED_CURRENT_WEAPON_TIME_BEFORE_NEXT_SHOT,0x75a8182479296220, CommandGetPedCurrentWeaponTimeBeforeNextShot);
|
|
|
|
SCR_REGISTER_SECURE(REFILL_AMMO_INSTANTLY,0x8cd8e9cb739389ac, CommandRefillAmmoInstant);
|
|
SCR_REGISTER_SECURE(MAKE_PED_RELOAD,0xf4d8955f68fa1058, CommandMakePedReload);
|
|
|
|
SCR_REGISTER_SECURE(REQUEST_WEAPON_ASSET,0x334e9a09859a3c8d, RequestWeaponAsset);
|
|
SCR_REGISTER_SECURE(HAS_WEAPON_ASSET_LOADED,0xc870cd3d6d40cb09, HasWeaponAssetLoaded);
|
|
SCR_REGISTER_SECURE(REMOVE_WEAPON_ASSET,0x315d54141149c1b6, RemoveWeaponAsset);
|
|
|
|
SCR_REGISTER_UNUSED(HAS_PED_GOT_WEAPON_MANAGER,0x67a9213e9840bae0, CommandHasPedGotWeaponManager);
|
|
|
|
SCR_REGISTER_SECURE(CREATE_WEAPON_OBJECT,0xbf59603e8a18feb0, CommandCreateWeaponObject);
|
|
SCR_REGISTER_SECURE(GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT,0x0b46dbce80ad9de5, CommandGiveWeaponComponentToWeaponObject);
|
|
SCR_REGISTER_SECURE(REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT,0x8d0169a2fdd87126, CommandRemoveWeaponComponentFromWeaponObject);
|
|
SCR_REGISTER_SECURE(HAS_WEAPON_GOT_WEAPON_COMPONENT,0xddc523d7b3e70e65, CommandHasWeaponGotWeaponComponent);
|
|
SCR_REGISTER_SECURE(GIVE_WEAPON_OBJECT_TO_PED,0x3aea6b9a9fe5bd26, CommandGiveWeaponObjectToPed);
|
|
SCR_REGISTER_SECURE(DOES_WEAPON_TAKE_WEAPON_COMPONENT,0xf387a3736de5f1d5, CommandDoesWeaponTakeWeaponComponent);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_OBJECT_FROM_PED,0x07093f8f06dd02ff, CommandGetWeaponObjectFromPed);
|
|
SCR_REGISTER_UNUSED(DROP_WEAPON_OBJECT_OF_PED,0xcb160c7b9368da2e, CommandDropWeaponObjectOfPed);
|
|
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_COMPONENT_NAME, 0x5972657f, CommandGetWeaponComponentName);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_COMPONENT_DESCRIPTION, 0x7a969327, CommandGetWeaponComponentDescription);
|
|
|
|
SCR_REGISTER_SECURE(GIVE_LOADOUT_TO_PED,0x588d77b641cbeddf, CommandGiveLoadOutToPed);
|
|
SCR_REGISTER_UNUSED(SET_LOADOUT_ALIAS,0xa1698d5b905894c0, CommandSetLoadOutAlias);
|
|
SCR_REGISTER_UNUSED(CLEAR_LOADOUT_ALIAS,0x27065729161c04e3, CommandClearLoadOutAlias);
|
|
|
|
SCR_REGISTER_SECURE(SET_PED_WEAPON_TINT_INDEX,0x7fec7f18430588cc, CommandSetPedWeaponTintIndex);
|
|
SCR_REGISTER_SECURE(GET_PED_WEAPON_TINT_INDEX,0xc158eb99f56cb1fb, CommandGetPedWeaponTintIndex);
|
|
SCR_REGISTER_SECURE(SET_WEAPON_OBJECT_TINT_INDEX,0x3e27bf30c58d41ec, CommandSetWeaponObjectTintIndex);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_OBJECT_TINT_INDEX,0xf22ab94467b80164, CommandGetWeaponObjectTintIndex);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_TINT_COUNT,0xdf7052e5c1ffbd7b, CommandGetWeaponTintCount);
|
|
|
|
SCR_REGISTER_SECURE(SET_PED_WEAPON_COMPONENT_TINT_INDEX,0xb7987e326f1fc793, CommandSetPedWeaponComponentTintIndex);
|
|
SCR_REGISTER_SECURE(GET_PED_WEAPON_COMPONENT_TINT_INDEX,0x6f970742b880af88, CommandGetPedWeaponComponentTintIndex);
|
|
SCR_REGISTER_SECURE(SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX,0x9a614f230d802f82, CommandSetWeaponObjectComponentTintIndex);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX,0xe4f0e3a023f6b91a, CommandGetWeaponObjectComponentTintIndex);
|
|
|
|
SCR_REGISTER_UNUSED(SET_PED_WEAPON_CAMO_INDEX,0x4c9ff1928a739330, CommandSetPedWeaponCamoIndex);
|
|
SCR_REGISTER_SECURE(GET_PED_WEAPON_CAMO_INDEX,0xef3626a1be542f5e, CommandGetPedWeaponCamoIndex);
|
|
SCR_REGISTER_SECURE(SET_WEAPON_OBJECT_CAMO_INDEX,0x7ccc68177a94f9be, CommandSetWeaponObjectCamoIndex);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_OBJECT_CAMO_INDEX,0x8a3d69849bd451fe, CommandGetWeaponObjectCamoIndex);
|
|
|
|
SCR_REGISTER_SECURE(GET_WEAPON_HUD_STATS,0x0eac086d816d5cb1, CommandGetWeaponHudStats);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_COMPONENT_HUD_STATS,0x8dc1b37fab5462c2, CommandGetWeaponComponentHudStats);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_DAMAGE,0x1c07375215a5ad6b, CommandGetWeaponDamage);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_CLIP_SIZE,0x982237eb68628e6a, CommandGetWeaponClipSize);
|
|
SCR_REGISTER_SECURE(GET_WEAPON_TIME_BETWEEN_SHOTS,0xfb17bb33ae9dea97, CommandGetWeaponTimeBetweenShots);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_ACCURACY,0xf104b3c55715593b, CommandGetWeaponAccuracy);
|
|
|
|
SCR_REGISTER_SECURE(SET_PED_CHANCE_OF_FIRING_BLANKS,0x1eabb8571d8c86d4, CommandSetPedChanceOfFiringBlanks);
|
|
|
|
SCR_REGISTER_SECURE(SET_PED_SHOOT_ORDNANCE_WEAPON,0x4afc09d27972d668, CommandSetPedShootOrdnanceWeapon);
|
|
|
|
SCR_REGISTER_SECURE(REQUEST_WEAPON_HIGH_DETAIL_MODEL,0x5f59388c2ba4ced1, CommandRequestWeaponHighDetailModel);
|
|
|
|
SCR_REGISTER_SECURE(SET_WEAPON_DAMAGE_MODIFIER,0x4e2c3699b7a57d47, CommandSetWeaponDamageModifier);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_DAMAGE_MODIFIER,0x6beddbd61f42d457, CommandGetWeaponDamageModifier);
|
|
SCR_REGISTER_UNUSED(SET_WEAPON_FALL_OFF_RANGE_MODIFIER,0xd2840ccee4fe0b3c, CommandSetWeaponFallOffRangeModifier);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_FALL_OFF_RANGE_MODIFIER,0xc7c9c0acd96afe6e, CommandGetWeaponFallOffRangeModifier);
|
|
SCR_REGISTER_UNUSED(SET_WEAPON_FALL_OFF_DAMAGE_MODIFIER,0xd8bdb556f05116ae, CommandSetWeaponFallOffDamageModifier);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_FALL_OFF_DAMAGE_MODIFIER, 0x2e3b8dacde116612, CommandGetWeaponFallOffDamageModifier);
|
|
SCR_REGISTER_SECURE(SET_WEAPON_AOE_MODIFIER,0x7a3cfc319adc00b2, CommandSetWeaponAoEModifier);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_AOE_MODIFIER,0x11179f4dbc8d7d0f, CommandGetWeaponAoEModifier);
|
|
SCR_REGISTER_SECURE(SET_WEAPON_EFFECT_DURATION_MODIFIER,0xca92f7e472406ec5, CommandSetWeaponEffectDurationModifier);
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_EFFECT_DURATION_MODIFIER,0x6b13c3b8b1a6d4b3, CommandGetWeaponEffectDurationModifier);
|
|
|
|
SCR_REGISTER_UNUSED(SET_RECOIL_ACCURACY_TO_ALLOW_HEADSHOT_PLAYER_MODIFIER,0xc7c735c837a6b4f9, CommandSetRecoilAccuracyToAllowHeadShotPlayerModifier);
|
|
SCR_REGISTER_UNUSED(GET_RECOIL_ACCURACY_TO_ALLOW_HEADSHOT_PLAYER_MODIFIER,0xe9c6043c02b779f1, CommandGetRecoilAccuracyToAllowHeadShotPlayerModifier);
|
|
SCR_REGISTER_UNUSED(SET_MIN_HEADSHOT_DISTANCE_PLAYER_MODIFIER,0xb4424a99f7c232cb, CommandSetMinHeadShotDistancePlayerModifier);
|
|
SCR_REGISTER_UNUSED(GET_MIN_HEADSHOT_DISTANCE_PLAYER_MODIFIER,0x63a1d467d86075da, CommandGetMinHeadShotDistancePlayerModifier);
|
|
SCR_REGISTER_UNUSED(SET_MAX_HEADSHOT_DISTANCE_PLAYER_MODIFIER,0xa0dcb3d3a2822b98, CommandSetMaxHeadShotDistancePlayerModifier);
|
|
SCR_REGISTER_UNUSED(GET_MAX_HEADSHOT_DISTANCE_PLAYER_MODIFIER,0xd7179c1ce2a3773a, CommandGetMaxHeadShotDistancePlayerModifier);
|
|
SCR_REGISTER_UNUSED(SET_HEADSHOT_DAMAGE_MODIFIER_PLAYER_MODIFIER,0x371fdb87c52a3699, CommandSetHeadShotDamageModifierPlayerModifier);
|
|
SCR_REGISTER_UNUSED(GET_HEADSHOT_DAMAGE_MODIFIER_PLAYER_MODIFIER,0x579d07ce7434c633, CommandGetHeadShotDamageModifierPlayerModifier);
|
|
|
|
SCR_REGISTER_SECURE(IS_PED_CURRENT_WEAPON_SILENCED,0x807d601fa146717a, CommandIsPedCurrentWeaponSilenced);
|
|
SCR_REGISTER_SECURE(IS_FLASH_LIGHT_ON,0xed91b91cc1189b30, CommandIsFlashLightOn);
|
|
SCR_REGISTER_SECURE(SET_FLASH_LIGHT_FADE_DISTANCE,0xf6fa7ffe56554d2a, CommandSetFlashlightFadeDistance);
|
|
SCR_REGISTER_SECURE(SET_FLASH_LIGHT_ACTIVE_HISTORY,0x5b71e8e84cae61b5, CommandSetFlashlightActiveHistory);
|
|
|
|
SCR_REGISTER_SECURE(SET_WEAPON_ANIMATION_OVERRIDE,0x5f04d63142241e1f, CommandWeaponAnimationOverride);
|
|
|
|
SCR_REGISTER_SECURE(GET_WEAPON_DAMAGE_TYPE,0x963bc5e5049966d1, CommandGetWeaponDamageType);
|
|
|
|
SCR_REGISTER_SECURE(SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED,0xf976379fb8b92eb4, CommandSetEqippedWeaponStartSpinningAtFullSpeed);
|
|
|
|
SCR_REGISTER_SECURE(CAN_USE_WEAPON_ON_PARACHUTE,0x64cdf8f5c3d31323, CommandCanUseWeaponOnParachute);
|
|
|
|
SCR_REGISTER_SECURE(CREATE_AIR_DEFENCE_SPHERE,0x28b8e32d8a6d5208, CommandCreateAirDefenceSphere);
|
|
SCR_REGISTER_SECURE(CREATE_AIR_DEFENCE_ANGLED_AREA,0xac8961b74e9fb713, CommandCreateAirDefenceAngledArea);
|
|
SCR_REGISTER_SECURE(REMOVE_AIR_DEFENCE_SPHERE,0x22833c17e06dae37, CommandRemoveAirDefenceSphere);
|
|
SCR_REGISTER_UNUSED(REMOVE_AIR_DEFENCE_SPHERES_INTERSECTING_POS,0xe1fcbc1d4d8a6885, CommandRemoveAirDefenceSpheresInteresectingPosition);
|
|
SCR_REGISTER_SECURE(REMOVE_ALL_AIR_DEFENCE_SPHERES,0xb4fc64537af766e8, CommandRemoveAllAirDefenceSpheres);
|
|
SCR_REGISTER_UNUSED(SET_PLAYER_TARGETTABLE_FOR_ALL_AIR_DEFENCE_SPHERES,0xa7cba54dd809ad23, CommandSetPlayerTargettableForAllAirDefenceSpheres);
|
|
SCR_REGISTER_SECURE(SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE,0x29827c14db83cc07, CommandSetPlayerTargettableForAirDefenceSphere);
|
|
SCR_REGISTER_UNUSED(RESET_PLAYER_TARGETTABLE_FLAGS_FOR_ALL_AIR_DEFENCE_SPHERES,0x3512766544034c1a, CommandResetPlayerTargettableFlagsForAllAirDefenceSpheres);
|
|
SCR_REGISTER_UNUSED(RESET_PLAYER_TARGETTABLE_FLAGS_FOR_AIR_DEFENCE_SPHERE,0xa3535755b04054d0, CommandResetPlayetTargettableFlagsForAirDefenceSphere);
|
|
SCR_REGISTER_SECURE(IS_AIR_DEFENCE_SPHERE_IN_AREA,0xe249916f8fdd6268, CommandIsAirDefenceSphereInArea);
|
|
SCR_REGISTER_SECURE(FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION,0xc6eda100ecf72aac, CommandFireAirDefenceSphereWeaponAtPosition);
|
|
SCR_REGISTER_SECURE(DOES_AIR_DEFENCE_SPHERE_EXIST,0xe2f5cc9ee3864144, CommandDoesAirDefenceSphereExist);
|
|
|
|
SCR_REGISTER_SECURE(SET_CAN_PED_SELECT_INVENTORY_WEAPON,0x9e40fd8565afbd17, CommandSetCanPedSelectIventoryWeapon);
|
|
SCR_REGISTER_SECURE(SET_CAN_PED_SELECT_ALL_WEAPONS,0x2155139b0979d9f6, CommandSetCanPedSelectAllWeapons);
|
|
|
|
SCR_REGISTER_UNUSED(GET_WEAPON_HAS_NON_LETHAL_TAG,0x1a6484d80213bf9a, CommandGetWeaponHasNonLethalTag);
|
|
}
|
|
|
|
}; //namespace weapon_commands
|