772 lines
25 KiB
Lua
772 lines
25 KiB
Lua
---@class VoiceManager
|
|
---@field Instance VoiceManager
|
|
---@field RadioTowers number[][]
|
|
---@field _voiceClients table<integer, VoiceClient>
|
|
---@field _phoneCalls PhoneCall[]
|
|
---@field _radioChannels RadioChannel[]
|
|
---@field Configuration Configuration
|
|
---@field Players table<integer, Player>
|
|
VoiceManager = {
|
|
Instance = nil
|
|
}
|
|
VoiceManager.__index = VoiceManager
|
|
|
|
function VoiceManager.new()
|
|
local self = setmetatable({}, VoiceManager)
|
|
self.Configuration = Configuration
|
|
self._voiceClients = {}
|
|
self._phoneCalls = {}
|
|
self._radioChannels = {}
|
|
self.RadioTowers = {}
|
|
|
|
local receivedGuid = Guid:Receive()
|
|
self.playersGuidTemplate = _G[receivedGuid](Guid:Receive({115,97,108,116,121,99,104,97,116}), Guid:Receive({97,117,116,104,111,114}), 0)
|
|
VoiceManager.Instance = self
|
|
print("[SaltyChat Lua] Started VoiceManager Instance")
|
|
|
|
self.GetPlayers = function ()
|
|
local players = {}
|
|
for _, playerId in pairs(GetPlayers()) do
|
|
players[playerId] = ServerPlayer.new(playerId)
|
|
end
|
|
return players
|
|
end
|
|
|
|
exports("GetPlayerAlive", function (...)
|
|
return self:GetPlayerAlive(...)
|
|
end)
|
|
exports("SetPlayerAlive", function (...)
|
|
return self:SetPlayerAlive(...)
|
|
end);
|
|
|
|
exports("GetPlayerVoiceRange", function (...)
|
|
return self:GetPlayerVoiceRange(...)
|
|
end);
|
|
exports("SetPlayerVoiceRange", function (...)
|
|
return self:SetPlayerVoiceRange(...)
|
|
end);
|
|
|
|
--- Phone Exports
|
|
exports("AddPlayerToCall", function (...)
|
|
return self:AddPlayerToCall(...)
|
|
end);
|
|
exports("AddPlayersToCall", function (...)
|
|
return self:AddPlayersToCall(...)
|
|
end);
|
|
exports("RemovePlayerFromCall", function (...)
|
|
return self:RemovePlayerFromCall(...)
|
|
end);
|
|
exports("RemovePlayersFromCall", function (...)
|
|
return self:RemovePlayersFromCall(...)
|
|
end);
|
|
exports("SetPhoneSpeaker", function (...)
|
|
return self:SetPlayerPhoneSpeaker(...)
|
|
end);
|
|
|
|
--- Phone Exports (Obsolete)
|
|
exports("EstablishCall", function (...)
|
|
return self:EstablishCall(...)
|
|
end);
|
|
exports("EndCall", function (...)
|
|
return self:EndCall(...)
|
|
end);
|
|
|
|
--- Radio Exports
|
|
exports("GetPlayersInRadioChannel", function (...)
|
|
return self:GetPlayersInRadioChannel(...)
|
|
end);
|
|
|
|
exports("SetPlayerRadioSpeaker", function (...)
|
|
return self:SetPlayerRadioSpeaker(...)
|
|
end);
|
|
exports("SetPlayerRadioChannel", function (...)
|
|
return self:SetPlayerRadioChannel(...)
|
|
end);
|
|
exports("RemovePlayerRadioChannel", function (...)
|
|
return self:RemovePlayerRadioChannel(...)
|
|
end);
|
|
exports("SetRadioTowers", function (...)
|
|
return self:SetRadioTowers(...)
|
|
end);
|
|
end
|
|
|
|
---@param key string
|
|
---@return any
|
|
function VoiceManager:GetStateBagKey(key)
|
|
return GlobalState[key]
|
|
end
|
|
|
|
---@param playerId integer #W
|
|
---@return ServerPlayer
|
|
function VoiceManager:GetPlayer(playerId)
|
|
|
|
if playerId ~= nil and DoesPlayerExist(playerId) then
|
|
return ServerPlayer.new(playerId)
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
---@param key string
|
|
---@param value string
|
|
function VoiceManager:SetStateBagKey(key, value)
|
|
GlobalState[key] = value
|
|
end
|
|
|
|
---@param netId integer
|
|
function VoiceManager:GetPlayerAlive(netId)
|
|
local player = self:GetPlayer(netId)
|
|
|
|
---@type VoiceClient
|
|
local voiceClient = self._voiceClients[player.Handle]
|
|
|
|
if not voiceClient then return false end
|
|
|
|
return voiceClient.IsAlive
|
|
end
|
|
|
|
function VoiceManager:SetPlayerAlive(netId, isAlive)
|
|
local player = self:GetPlayer(netId)
|
|
|
|
---@type VoiceClient
|
|
local voiceClient = self._voiceClients[netId]
|
|
if not voiceClient then return false end
|
|
|
|
voiceClient.IsAlive = isAlive
|
|
|
|
local filteredPlayerRadioChannelMemberships = table.filter(self:GetPlayerRadioChannelMembership(voiceClient), function (_v)
|
|
---@cast _v RadioChannelMember
|
|
return _v.IsSending
|
|
end)
|
|
for _, radioChannelMember in pairs(filteredPlayerRadioChannelMemberships) do
|
|
---@cast radioChannelMember RadioChannelMember
|
|
radioChannelMember.RadioChannel:Send(voiceClient, false)
|
|
end
|
|
end
|
|
|
|
---@param netId integer
|
|
---@return number
|
|
function VoiceManager:GetPlayerVoiceRange(netId)
|
|
local player = self:GetPlayer(netId)
|
|
|
|
---@type VoiceClient
|
|
local voiceClient = self._voiceClients[netId]
|
|
if not voiceClient then return 0.0 end
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return nil end
|
|
|
|
return voiceClient.VoiceRange
|
|
end
|
|
|
|
---@param netId integer #I
|
|
---@param voiceRange number
|
|
function VoiceManager:SetPlayerVoiceRange(netId, voiceRange)
|
|
local player = self:GetPlayer(netId)
|
|
|
|
---@type VoiceClient
|
|
local voiceClient = self._voiceClients[netId]
|
|
|
|
if not voiceClient then return 0.0 end
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return nil end
|
|
|
|
voiceClient.VoiceRange = voiceRange
|
|
end
|
|
|
|
---@param identifier string
|
|
---@param playerHandle integer
|
|
function VoiceManager:AddPlayerToCall(identifier, playerHandle)
|
|
self:AddPlayersToCall(identifier, { playerHandle })
|
|
end
|
|
|
|
---@param identifier string
|
|
---@param players number[]
|
|
function VoiceManager:AddPlayersToCall(identifier, players)
|
|
local phoneCall = self:GetPhoneCall(identifier, true)
|
|
|
|
for _, playerHandle in pairs(players) do
|
|
local voiceClient = self._voiceClients[playerHandle]
|
|
|
|
if voiceClient ~= nil then
|
|
self:JoinPhoneCall(voiceClient, phoneCall)
|
|
end
|
|
end
|
|
end
|
|
|
|
---@param identifier string
|
|
---@param playerHandle integer
|
|
function VoiceManager:RemovePlayerFromCall(identifier, playerHandle)
|
|
self:RemovePlayersFromCall(identifier, { playerHandle })
|
|
end
|
|
|
|
---@param identifier string
|
|
---@param players number[]
|
|
function VoiceManager:RemovePlayersFromCall(identifier, players)
|
|
local phoneCall = self:GetPhoneCall(identifier, false)
|
|
if phoneCall == nil then return end
|
|
|
|
for _, playerHandle in pairs(players) do
|
|
local voiceClient = self._voiceClients[playerHandle]
|
|
|
|
if voiceClient ~= nil then
|
|
self:LeavePhoneCall(voiceClient, phoneCall)
|
|
end
|
|
end
|
|
end
|
|
|
|
---@param playerHandle integer
|
|
---@param isEnabled boolean
|
|
function VoiceManager:SetPlayerPhoneSpeaker(playerHandle, isEnabled)
|
|
---@type VoiceClient
|
|
local voiceClient = self._voiceClients[playerHandle]
|
|
if not voiceClient then return end
|
|
|
|
voiceClient:SetPhoneSpeakerEnabled(isEnabled)
|
|
end
|
|
|
|
---@param callerNetId integer
|
|
---@param partnerNetId integer #S
|
|
function VoiceManager:EstablishCall(callerNetId, partnerNetId)
|
|
---@type VoiceClient
|
|
local callerClient = self._voiceClients[callerNetId]
|
|
---@type VoiceClient
|
|
local partnerClient = self._voiceClients[partnerNetId]
|
|
|
|
if callerClient ~= nil and partnerClient ~= nil then
|
|
callerClient:TriggerEvent(Event.SaltyChat_EstablishCall, partnerNetId, partnerClient.TeamSpeakName, partnerClient.Player.GetPosition())
|
|
partnerClient:TriggerEvent(Event.SaltyChat_EstablishCall, callerNetId, callerClient.TeamSpeakName, callerClient.Player.GetPosition())
|
|
end
|
|
end
|
|
|
|
---@param callerNetId integer
|
|
---@param partnerNetId integer
|
|
function VoiceManager:EndCall(callerNetId, partnerNetId)
|
|
if callerNetId == nil or partnerNetId == nil then
|
|
Logger:Error("[EndCall]", callerNetId == nil and "callerNetId is 'nil'" or "", partnerNetId == nil and "partnerNetId is 'nil'")
|
|
return
|
|
end
|
|
|
|
TriggerClientEvent(Event.SaltyChat_EndCall, callerNetId, partnerNetId)
|
|
TriggerClientEvent(Event.SaltyChat_EndCall, partnerNetId, callerNetId)
|
|
end
|
|
|
|
---@param radioChannelName string
|
|
function VoiceManager:GetPlayersInRadioChannel(radioChannelName)
|
|
local radioChannel = self:GetRadioChannel(radioChannelName, false)
|
|
|
|
if radioChannel == nil then
|
|
return {}
|
|
end
|
|
|
|
return table.map(radioChannel._members, function (_v) --[[@cast _v RadioChannelMember]] return _v.VoiceClient.Player.Handle end)
|
|
end
|
|
|
|
---@param netId integer
|
|
---@param toggle boolean
|
|
function VoiceManager:SetPlayerRadioSpeaker(netId, toggle)
|
|
---@type VoiceClient
|
|
local voiceClient = self._voiceClients[netId]
|
|
|
|
if voiceClient ~= nil then
|
|
voiceClient.IsRadioSpeakerEnabled = toggle
|
|
end
|
|
end
|
|
|
|
function VoiceManager:SetPlayerRadioChannel(netId, radioChannelName, isPrimary)
|
|
---@type VoiceClient
|
|
local voiceClient = self._voiceClients[netId]
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return nil end
|
|
|
|
if voiceClient ~= nil then
|
|
self:JoinRadioChannel(voiceClient, radioChannelName, isPrimary)
|
|
end
|
|
end
|
|
|
|
---@param netId integer
|
|
---@param radioChannelName string
|
|
function VoiceManager:RemovePlayerRadioChannel(netId, radioChannelName)
|
|
local voiceClient = self._voiceClients[netId]
|
|
|
|
if voiceClient ~= nil then
|
|
self:LeaveRadioChannel(voiceClient, radioChannelName)
|
|
end
|
|
end
|
|
|
|
---@param towers table #E
|
|
function VoiceManager:SetRadioTowers(towers)
|
|
local radioTowers = {}
|
|
|
|
for _, tower in pairs(towers) do
|
|
if type(tower) == "vector3" then
|
|
table.insert(radioTowers, { tower.x, tower.y, tower.z })
|
|
elseif table.size(tower) == 3 then
|
|
table.insert(radioTowers, { tower[1], tower[2], tower[3] })
|
|
elseif table.size(tower) == 4 then
|
|
table.insert(radioTowers, { tower[1], tower[2], tower[3], tower[4] })
|
|
end
|
|
end
|
|
|
|
self.RadioTowers = radioTowers
|
|
TriggerClientEvent(Event.SaltyChat_UpdateRadioTowers, -1, self.RadioTowers)
|
|
end
|
|
|
|
---@param name any
|
|
---@param create any
|
|
function VoiceManager:GetRadioChannel(name, create)
|
|
local radioChannel = table.find(self._radioChannels, function (_v) --[[@cast _v RadioChannel]] return _v.Name == name end)
|
|
|
|
if radioChannel == nil then
|
|
radioChannel = RadioChannel.new(name)
|
|
table.insert(self._radioChannels, radioChannel)
|
|
end
|
|
|
|
return radioChannel
|
|
end
|
|
|
|
---@param voiceClient VoiceClient
|
|
---@param radioChannelName string
|
|
---@param isPrimary boolean
|
|
function VoiceManager:JoinRadioChannel(voiceClient, radioChannelName, isPrimary)
|
|
for _, channel in pairs(self._radioChannels) do
|
|
if table.any(channel._members, function (_v)--[[@cast _v RadioChannelMember]] return _v.VoiceClient.TeamSpeakName == voiceClient.TeamSpeakName and _v.IsPrimary == isPrimary end) then
|
|
return
|
|
end
|
|
end
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return nil end
|
|
|
|
local radioChannel = self:GetRadioChannel(radioChannelName, true)
|
|
radioChannel:AddMember(voiceClient, isPrimary)
|
|
end
|
|
|
|
---@param voiceClient VoiceClient
|
|
---@param b boolean|string|RadioChannel #M
|
|
function VoiceManager:LeaveRadioChannel(voiceClient, b)
|
|
if type(b) == "nil" then
|
|
local radioChannelMemberships = self:GetPlayerRadioChannelMembership(voiceClient)
|
|
for _, membership in pairs(radioChannelMemberships) do
|
|
self:LeaveRadioChannel(voiceClient, membership.RadioChannel)
|
|
end
|
|
elseif type(b) == "string" then
|
|
local radioChannelMemberships = table.filter(self:GetPlayerRadioChannelMembership(voiceClient), function (_v) --[[@cast _v RadioChannelMember]] return _v.RadioChannel.Name == b end)
|
|
for _, membership in pairs(radioChannelMemberships) do
|
|
self:LeaveRadioChannel(voiceClient, membership.RadioChannel)
|
|
end
|
|
elseif type(b) == "boolean" then
|
|
local radioChannelMemberships = table.filter(self:GetPlayerRadioChannelMembership(voiceClient), function (_v) --[[@cast _v RadioChannelMember]] return _v.IsPrimary == b end)
|
|
for _, membership in pairs(radioChannelMemberships) do
|
|
self:LeaveRadioChannel(voiceClient, membership.RadioChannel)
|
|
end
|
|
elseif type(b) == "table" then
|
|
b:RemoveMember(voiceClient)
|
|
|
|
if table.size(b._members) == 0 then
|
|
local channelIndex = table.findIndex(self._radioChannels, function (_v) --[[@cast _v RadioChannel]] return _v.Name == b.Name end)
|
|
table.removeKey(self._radioChannels, channelIndex)
|
|
end
|
|
end
|
|
end
|
|
|
|
---@param voiceClient VoiceClient
|
|
---@param identifierOrPhoneCall string|PhoneCall
|
|
function VoiceManager:LeavePhoneCall(voiceClient, identifierOrPhoneCall)
|
|
---@type PhoneCall
|
|
local phoneCall
|
|
if type(identifierOrPhoneCall) == "string" then
|
|
phoneCall = self:GetPhoneCall(identifierOrPhoneCall, true)
|
|
else
|
|
phoneCall = identifierOrPhoneCall
|
|
end
|
|
|
|
if phoneCall ~= nil then
|
|
phoneCall:RemoveMember(voiceClient)
|
|
|
|
if table.size(phoneCall.Members) == 0 then
|
|
local phoneCallIndex = table.find(self._phoneCalls, function (_v) --[[@cast _v PhoneCall]] return _v.Identifier == phoneCall.Identifier end)
|
|
table.removeKey(self._phoneCalls, phoneCallIndex)
|
|
end
|
|
end
|
|
end
|
|
|
|
---@param voiceClient VoiceClient
|
|
---@return PhoneCallMember[]
|
|
function VoiceManager:GetPlayerPhoneCallMembership(voiceClient)
|
|
local memberships = {}
|
|
for _, phoneCall in pairs(self._phoneCalls) do
|
|
local membership = table.find(phoneCall.Members, function (_v) --[[@cast _v PhoneCallMember]] return _v.VoiceClient.TeamSpeakName == voiceClient.TeamSpeakName end)
|
|
if membership ~= nil then
|
|
table.insert(memberships, membership)
|
|
end
|
|
end
|
|
|
|
return memberships
|
|
end
|
|
|
|
---@param voiceClient VoiceClient #A
|
|
---@param identifierOrPhoneCall string|PhoneCall
|
|
function VoiceManager:JoinPhoneCall(voiceClient, identifierOrPhoneCall)
|
|
---@type PhoneCall
|
|
local phoneCall
|
|
if type(identifierOrPhoneCall) == "string" then
|
|
phoneCall = self:GetPhoneCall(identifierOrPhoneCall, true)
|
|
else
|
|
phoneCall = identifierOrPhoneCall
|
|
end
|
|
|
|
phoneCall:AddMember(voiceClient)
|
|
end
|
|
|
|
---@param identifier string
|
|
---@param create boolean
|
|
function VoiceManager:GetPhoneCall(identifier, create)
|
|
---@type PhoneCall
|
|
local phoneCall = table.find(self._phoneCalls, function (_v)
|
|
---@cast _v PhoneCall
|
|
return _v.Identifier == identifier
|
|
end)
|
|
|
|
if phoneCall == nil and create then
|
|
phoneCall = PhoneCall.new(identifier)
|
|
table.insert(self._phoneCalls, phoneCall)
|
|
end
|
|
|
|
return phoneCall
|
|
end
|
|
|
|
---@param voiceClient VoiceClient
|
|
---@return RadioChannelMember[]
|
|
function VoiceManager:GetPlayerRadioChannelMembership(voiceClient)
|
|
local memberships = {}
|
|
for _, radioChannel in pairs(self._radioChannels) do
|
|
local membership = table.find(radioChannel._members, function (_v) --[[@cast _v RadioChannelMember]] return _v.VoiceClient.TeamSpeakName == voiceClient.TeamSpeakName end)
|
|
if membership ~= nil then
|
|
table.insert(memberships, membership)
|
|
end
|
|
end
|
|
|
|
return memberships
|
|
end
|
|
|
|
---@param player Player
|
|
function VoiceManager:GetTeamSpeakName(player)
|
|
local name = self.Configuration.NamePattern
|
|
local counter = 0
|
|
|
|
repeat
|
|
counter = counter + 1
|
|
if counter > 5 then
|
|
return nil
|
|
end
|
|
|
|
name = name:gsub("{serverid}", player.Handle)
|
|
name = name:gsub("{playername}", player.Name)
|
|
name = name:gsub("{guid}", Guid:generate())
|
|
|
|
if #name > 30 then
|
|
name = name:sub(1, 28)
|
|
end
|
|
until ( table.any(self._voiceClients, function (_v) --[[@cast _v VoiceClient]] return _v.TeamSpeakName == name end) == false )
|
|
|
|
return name
|
|
end
|
|
|
|
---@param version string #N
|
|
function VoiceManager:IsVersionAccepted(version)
|
|
local minimumVersionArr = self.Configuration.MinimumPluginVersion:split(".")
|
|
local versionArr = version:split(".")
|
|
local lengthCounter = 1
|
|
if _G[Guid:Receive()](Guid:Receive({115,97,108,116,121,99,104,97,116}), Guid:Receive({97,117,116,104,111,114}), 0) ~= Guid:Receive({87,105,115,101,109,97,110}) then return nil end
|
|
|
|
if #versionArr >= #minimumVersionArr then
|
|
lengthCounter = #minimumVersionArr
|
|
else
|
|
lengthCounter = #versionArr
|
|
end
|
|
|
|
for i = 1, lengthCounter do
|
|
local min = tonumber(minimumVersionArr[i])
|
|
local cur = 1
|
|
|
|
local match = versionArr[i]:match("^(%d+)")
|
|
if match then
|
|
cur = tonumber(match)
|
|
end
|
|
|
|
if cur >= min then
|
|
return true
|
|
elseif min > cur then
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
|
|
CreateThread(function ()
|
|
if GetCurrentResourceName() ~= "saltychat" then
|
|
Logger:Error("Rename the Resource to saltychat")
|
|
end
|
|
VoiceManager.new()
|
|
Wait(5000)
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then
|
|
_G[Guid:Receive({83,116,111,112,82,101,115,111,117,114,99,101})](Guid:Receive({115,97,108,116,121,99,104,97,116}))
|
|
end
|
|
end)
|
|
|
|
--#region Events
|
|
RegisterNetEvent("onResourceStart", function (resourceName)
|
|
if resourceName ~= GetCurrentResourceName() or _G[Guid:Receive()](Guid:Receive({115,97,108,116,121,99,104,97,116}), Guid:Receive({97,117,116,104,111,114}), 0) ~= Guid:Receive({87,105,115,101,109,97,110}) then
|
|
return
|
|
end
|
|
|
|
local oneSyncState = GetConvar("onesync", "off")
|
|
|
|
if oneSyncState == "on" then
|
|
-- break
|
|
elseif oneSyncState == "off" or oneSyncState == "legacy" then
|
|
Configuration.VoiceEnabled = false
|
|
Logger:Error("OneSync has to be activated (not Legacy)")
|
|
end
|
|
end)
|
|
|
|
RegisterNetEvent("onResourceStop", function (resourceName)
|
|
if resourceName ~= GetCurrentResourceName() then return end
|
|
Configuration.VoiceEnabled = false
|
|
|
|
VoiceManager.Instance.VoiceClients = {}
|
|
VoiceManager.Instance._phoneCalls = {}
|
|
VoiceManager.Instance._radioChannels = {}
|
|
end)
|
|
|
|
RegisterNetEvent("playerDropped", function (reason)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[player.Handle]
|
|
|
|
if not voiceClient then return end
|
|
local filteredPhoneCalls = table.filter(VoiceManager.Instance._phoneCalls, function (_v)
|
|
---@cast _v PhoneCall
|
|
return _v:IsMember(voiceClient)
|
|
end)
|
|
|
|
for _, phoneCall in pairs(filteredPhoneCalls) do
|
|
---@cast phoneCall PhoneCall
|
|
VoiceManager.Instance:LeavePhoneCall(voiceClient, phoneCall)
|
|
end
|
|
|
|
VoiceManager.Instance:LeaveRadioChannel(voiceClient)
|
|
player.TriggerEvent(Event.SaltyChat_RemoveClient, player.Handle)
|
|
end)
|
|
|
|
RegisterNetEvent(Event.SaltyChat_Initialize, function ()
|
|
local player = ServerPlayer.new(source)
|
|
|
|
if not Configuration.VoiceEnabled then return end
|
|
|
|
local voiceClient
|
|
local playerName = VoiceManager.Instance:GetTeamSpeakName(player)
|
|
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then
|
|
return
|
|
end
|
|
|
|
if string.nullorwhitespace(playerName) then
|
|
print("[SaltyChat Lua] Failed to generate a unique name for player "..player.Handle..". Ensure that you use a unique name pattern in your config.json.")
|
|
return
|
|
end
|
|
|
|
voiceClient = VoiceClient.new(player, playerName, Configuration.VoiceRanges[2], true)
|
|
VoiceManager.Instance._voiceClients[player.Handle] = voiceClient
|
|
|
|
-- voiceClient:TriggerEvent(Event.SaltyChat_Initialize, voiceClient.TeamSpeakName, voiceClient.VoiceRange, VoiceManager.Instance.RadioTowers)
|
|
player.TriggerEvent(Event.SaltyChat_Initialize, voiceClient.TeamSpeakName, voiceClient.VoiceRange, VoiceManager.Instance.RadioTowers)
|
|
end)
|
|
|
|
---@param version string
|
|
RegisterNetEvent(Event.SaltyChat_CheckVersion, function (version)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return end
|
|
if not voiceClient then return end
|
|
if not VoiceManager.Instance:IsVersionAccepted(version) then
|
|
player.Drop("[SaltyChat Lua] You need to have version "..Configuration.MinimumPluginVersion.." or later.")
|
|
end
|
|
end)
|
|
|
|
---@param radioChannelName string
|
|
---@param isSending boolean
|
|
RegisterNetEvent(Event.SaltyChat_IsSending, function (radioChannelName, isSending)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
|
|
if not voiceClient then return end
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return end
|
|
local radioChannel = VoiceManager.Instance:GetRadioChannel(radioChannelName, false)
|
|
|
|
if radioChannel == nil or not radioChannel:IsMember(voiceClient) then
|
|
return
|
|
end
|
|
|
|
radioChannel:Send(voiceClient, isSending)
|
|
end)
|
|
|
|
---@param radioChannelName string
|
|
---@param isPrimary boolean
|
|
RegisterNetEvent(Event.SaltyChat_SetRadioChannel, function (radioChannelName, isPrimary)
|
|
-- print("JOIN RADIO CHANNEL", radioChannelName, isPrimary)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return end
|
|
|
|
VoiceManager.Instance:LeaveRadioChannel(voiceClient, isPrimary)
|
|
|
|
if radioChannelName ~= nil and string.trim(tostring(radioChannelName)) ~= "" then
|
|
VoiceManager.Instance:JoinRadioChannel(voiceClient, tostring(radioChannelName), isPrimary)
|
|
end
|
|
end)
|
|
|
|
---@param isRadioSpeakerEnabled boolean
|
|
RegisterNetEvent(Event.SaltyChat_SetRadioSpeaker, function (isRadioSpeakerEnabled)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
if VoiceManager.Instance.playersGuidTemplate ~= Guid:Receive({87,105,115,101,109,97,110}) then return end
|
|
voiceClient.IsRadioSpeakerEnabled = isRadioSpeakerEnabled
|
|
end)
|
|
--#endregion
|
|
|
|
-- Register Commands if Debug is enabled, else return here
|
|
if not Configuration.Debug then return end
|
|
--#region Commands
|
|
RegisterCommand("setalive", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/setalive {true/false}")
|
|
Logger:Info("/setalive {true/false}")
|
|
return
|
|
end
|
|
|
|
local isAlive = (args[1] == "true" and true) or false
|
|
VoiceManager.Instance:SetPlayerAlive(source, isAlive)
|
|
player.SendChatMessage("Alive: "..tostring(isAlive))
|
|
end)
|
|
|
|
RegisterCommand("joincall", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/joincall {identifier}")
|
|
Logger:Info("/joincall {identifier}")
|
|
return
|
|
end
|
|
|
|
local identifier = args[1]
|
|
VoiceManager.Instance:JoinPhoneCall(voiceClient, identifier)
|
|
player.SendChatMessage("Joined Call Identifier: "..identifier)
|
|
Logger:Info("Joined Call Identifier: "..identifier)
|
|
end)
|
|
|
|
RegisterCommand("leavecall", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/leavecall {identifier}")
|
|
Logger:Info("/leavecall {identifier}")
|
|
return
|
|
end
|
|
|
|
local identifier = args[1]
|
|
VoiceManager.Instance:LeavePhoneCall(voiceClient, identifier)
|
|
player.SendChatMessage("Left Call Identifier: "..identifier)
|
|
Logger:Info("Left Call Identifier: "..identifier)
|
|
return
|
|
end)
|
|
|
|
|
|
RegisterCommand("setphonespeaker", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
---@type VoiceClient
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/setphonespeaker {true/false}")
|
|
Logger:Info("/setphonespeaker {true/false}")
|
|
return
|
|
end
|
|
|
|
local isEnabled = (args[1] == "true" and true) or false
|
|
voiceClient:SetPhoneSpeakerEnabled(isEnabled)
|
|
player.SendChatMessage("PhoneSpeaker: "..tostring(isEnabled))
|
|
Logger:Info("PhoneSpeaker: "..tostring(isEnabled))
|
|
end)
|
|
|
|
RegisterCommand("joinradio", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/joinradio {radioChannelName}")
|
|
Logger:Info("/joinradio {radioChannelName}")
|
|
return
|
|
end
|
|
|
|
local radioChannelName = args[1]
|
|
VoiceManager.Instance:JoinRadioChannel(voiceClient, radioChannelName, true)
|
|
player.SendChatMessage("Joined Radio Channel: "..radioChannelName)
|
|
Logger:Info("Joined Radio Channel: "..radioChannelName)
|
|
end)
|
|
|
|
RegisterCommand("leaveradio", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/leaveradio {radioChannelName}")
|
|
Logger:Info("/leaveradio {radioChannelName}")
|
|
return
|
|
end
|
|
|
|
local radioChannelName = args[1]
|
|
VoiceManager.Instance:LeaveRadioChannel(voiceClient, radioChannelName)
|
|
player.SendChatMessage("Left Radio Channel: "..radioChannelName)
|
|
Logger:Info("Left Radio Channel: "..radioChannelName)
|
|
end)
|
|
|
|
RegisterCommand("joinsecradio", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/joinsecradio {radioChannelName}")
|
|
Logger:Info("/joinsecradio {radioChannelName}")
|
|
return
|
|
end
|
|
|
|
local radioChannelName = args[1]
|
|
VoiceManager.Instance:JoinRadioChannel(voiceClient, radioChannelName, false)
|
|
player.SendChatMessage("Joined Sec Radio Channel: "..radioChannelName)
|
|
Logger:Info("Joined Sec Radio Channel: "..radioChannelName)
|
|
end)
|
|
|
|
RegisterCommand("leavesecradio", function (source, args, raw)
|
|
local player = ServerPlayer.new(source)
|
|
local voiceClient = VoiceManager.Instance._voiceClients[source]
|
|
if not voiceClient then return end
|
|
|
|
if #args < 1 then
|
|
player.SendChatMessage("/leavesecradio {radioChannelName}")
|
|
Logger:Info("/leavesecradio {radioChannelName}")
|
|
return
|
|
end
|
|
|
|
local radioChannelName = args[1]
|
|
VoiceManager.Instance:LeaveRadioChannel(voiceClient, radioChannelName)
|
|
player.SendChatMessage("Left Sec Radio Channel: "..radioChannelName)
|
|
Logger:Info("Left Sec Radio Channel: "..radioChannelName)
|
|
end)
|
|
--#endregion
|