sreVprefixidi\acre\addons\sys_externalCfgEventHandlers.hppCfgVehicles.hppconfig.binhhfnc_allowExternalUse.sqffnc_checkListChildrenActions.sqffnc_checkReturnGive.sqf//fnc_childrenActions.sqfQ Q fnc_externalRadioPFH.sqffnc_getExternalRadioOwner.sqf''fnc_getExternalRadioUser.sqffnc_getExternalUseStatus.sqfaafnc_getSharedExternalRadios.sqffnc_initRadio.sqffnc_isExternalActionAvailable.sqf}}fnc_isExternalRadioAvailable.sqffnc_isExternalRadioUsed.sqffnc_isRadioShared.sqffnc_listChildrenActions.sqf55fnc_onPlayerKilled.sqffnc_radioCheckChildrenActions.sqffnc_startUsingExternalRadio.sqf--fnc_stopUsingExternalRadio.sqfRRscript_component.hppstringtable.xmlg'g'XEH_postInit.sqf||XEH_preInit.sqfXEH_PREP.hpp,,XEH_preStart.sqf<<class Extended_PreStart_EventHandlers { class ADDON { init = QUOTE(call COMPILE_FILE(XEH_preStart)); }; }; class Extended_PreInit_EventHandlers { class ADDON { init = QUOTE(call COMPILE_FILE(XEH_preInit)); }; }; class Extended_PostInit_EventHandlers { class ADDON { init = QUOTE(call COMPILE_FILE(XEH_postInit)); }; }; class Extended_Killed_EventHandlers { class Man { ADDON = QUOTE(_this call FUNC(onPlayerKilled)); }; }; class CfgVehicles { class Man; class CAManBase: Man { class ACE_Actions { class ACE_MainActions { class ACRE_Interact_External { displayName = CSTRING(externalRadios); condition = QUOTE(_this call FUNC(isExternalActionAvailable)); exceptions[] = {"isNotInside", "isNotSitting"}; statement = "true"; insertChildren = QUOTE(_this call FUNC(listChildrenActions)); priority = 0.1; icon = ICON_RADIO_CALL; }; }; }; }; }; raPdCfgPatchesCfgVehiclesExtended_PreStart_EventHandlersExtended_PreInit_EventHandlers Extended_PostInit_EventHandlersExtended_Killed_EventHandlersacre_sys_external nameACRE2 - External RadiosunitsweaponsrequiredVersionG@requiredAddonsacre_mainacre_sys_coreacre_sys_dataauthor$STR_acre_main_AuthorauthorsTheMagnetarSnippersurl$STR_acre_main_URLversion9@versionStr2.9.0.1042versionAr ManCAManBaseManACE_Actions+ACE_MainActionsBACRE_Interact_External`displayName$STR_acre_sys_external_externalRadioscondition_this call acre_sys_external_fnc_isExternalActionAvailableexceptionsisNotInsideisNotSittingstatementtrueinsertChildren_this call acre_sys_external_fnc_listChildrenActionspriority=icon\a3\Ui_f\data\GUI\Cfg\CommunicationMenu\call_ca.paaacre_sys_externalinitcall compile preprocessFileLineNumbers '\idi\acre\addons\sys_external\XEH_preStart.sqf'acre_sys_external9initcall compile preprocessFileLineNumbers '\idi\acre\addons\sys_external\XEH_preInit.sqf'acre_sys_externalinitcall compile preprocessFileLineNumbers '\idi\acre\addons\sys_external\XEH_postInit.sqf'Manacre_sys_external_this call acre_sys_external_fnc_onPlayerKilled#include "script_component.hpp" /* * Author: ACRE2Team * Mark a radio in order to enable/disable to be used by other units (external use). * * Arguments: * 0: Unique radio identity * 1: Enable or disable sharing * * Return Value: * None * * Example: * ["ACRE_PRC343_ID_1", false] call acre_sys_external_fnc_allowExternalUse * * Public: No */ params ["_radioId", "_allowExternalUse"]; [_radioId, "setState", ["radioShared", _allowExternalUse]] call EFUNC(sys_data,dataEvent); #include "script_component.hpp" /* * Author: ACRE2Team * Check if a given action is available for a specific radio and unit. * * Arguments: * 0: Unique radio ID * 1: Unit to be checked * * Return Value: * Action is available * * Example: * [cursorTarget] call acre_sys_external_fnc_checkListChildrenActions * * Public: No */ params ["_radioId", "_unit"]; private _isAvailable = true; // Params are _isShared, _isUsedExternally, _owner and _user) ([_radioId] call FUNC(getExternalUseStatus)) params ["", "_isUsedExternally", "", "_user"]; // Do not allow an external user to return the headset if the radio is in use if (_isUsedExternally && {_unit != _user}) exitWith {false}; // Prevent from taking a radio that can be also heard through the intercom or directly accessible racks if ([_radioId, _unit] call EFUNC(sys_rack,isRadioHearable) || {[_radioId, _unit] call EFUNC(sys_rack,isRadioAccessible)}) exitWith {false}; _isAvailable #include "script_component.hpp" /* * Author: ACRE2Team * Check if a radio being used externally is being returned to the owner or given to another unit. * * Arguments: * 1: Unique radio ID * 0: Unit to be given/returned a radio * * Return Value: * Radio is returned (true) or given (false) * * Example: * [cursorTarget] call acre_sys_external_fnc_checkReturnGive * * Public: No */ params ["_radioId", "_target"]; private _owner = [_radioId] call FUNC(getExternalRadioOwner); _owner == _target #include "script_component.hpp" /* * Author: ACRE2Team * Generates a list of actions for using a radio externaly. * * Arguments: * 0: Unit with a shared radio * 1: None * 2: Array with additional parameters * 0: Unique radio ID * * Return Value: * Array of actions * * Example: * [cursorTarget, "", ["ACRE_PRC343_ID_1"]] call acre_sys_external_fnc_childrenActions * * Public: No */ params ["_target", "", "_params"]; _params params ["_radio"]; private _actions = []; private _playerOwnsRadio = acre_player == [_radio] call FUNC(getExternalRadioOwner); if (_playerOwnsRadio) then { private _string = localize LSTRING(giveHeadset); if ([_radio] call EFUNC(sys_radio,isManpackRadio)) then { _string = localize LSTRING(giveHandset) }; private _action = [ QGVAR(giveRadio), _string, "", {[_this select 2, _target] call FUNC(stopUsingExternalRadio)}, {!([_this select 2] call FUNC(isExternalRadioUsed))}, {}, _radio ] call ace_interact_menu_fnc_createAction; _actions pushBack [_action, [], _target]; } else { private _string = localize LSTRING(takeHeadset); if ([_radio] call EFUNC(sys_radio,isManpackRadio)) then { _string = localize LSTRING(takeHandset) }; private _action = [ QGVAR(useRadio), _string, "", {[_this select 2, acre_player] call FUNC(startUsingExternalRadio)}, {!([_this select 2] call FUNC(isExternalRadioUsed))}, {}, _radio ] call ace_interact_menu_fnc_createAction; _actions pushBack [_action, [], _target]; }; // Check if we are giving or returning the headset if ([_radio, _target] call FUNC(checkReturnGive)) then { private _string = localize LSTRING(returnHeadset); if ([_radio] call EFUNC(sys_radio,isManpackRadio)) then { _string = localize LSTRING(returnHandset) }; private _action = [ QGVAR(returnRadio), _string, "", {[_this select 2, _target] call FUNC(stopUsingExternalRadio)}, {[_this select 2] call FUNC(isExternalRadioUsed)}, {}, _radio ] call ace_interact_menu_fnc_createAction; _actions pushBack [_action, [], _target]; } else { private _string = localize LSTRING(giveHeadset); if ([_radio] call EFUNC(sys_radio,isManpackRadio)) then { _string = localize LSTRING(giveHandset) }; private _action = [ QGVAR(giveRadio), _string, "", {[_this select 2, _target] call FUNC(stopUsingExternalRadio)}, {[_this select 2] call FUNC(isExternalRadioUsed)}, {}, _radio ] call ace_interact_menu_fnc_createAction; _actions pushBack [_action, [], _target]; }; _actions #include "script_component.hpp" /* * Author: ACRE2Team * Eventhandler to monitor if external radios can be still used by a specific player. * * - Disabled uses of external radios are: * - Radio is in players inventory. * - Distance between owner and end user is greater than 2m. * - Owner and end user are not in the same vehicle. * - Death of player is handled in fnc_onPlayerKilled.sqf. * - Radios in dead or captive units can always be accessed by other players. * * Arguments: * None * * Return Value: * None * * Example: * [] call acre_sys_external_fnc_externalRadioPFH * * Public: No */ /* TODO: * - Consider further corner cases. */ if (alive acre_player) then { // Check if we need to remove active radios private _radios = [acre_player] call EFUNC(sys_core,getGear); { // Remove radios that are in unit's inventory or match a certain criteria. private _owner = [_x] call FUNC(getExternalRadioOwner); private _isExternalRadioAvailable = [_x, _owner] call FUNC(isExternalRadioAvailable); if (!_isExternalRadioAvailable || {_x in _radios}) then { [_x, _owner] call FUNC(stopUsingExternalRadio); }; } forEach ACRE_ACTIVE_EXTERNAL_RADIOS; }; #include "script_component.hpp" /* * Author: ACRE2Team * Retrieves the owner of a radio that is being used externally. * * Arguments: * 0: Unique radio identity * * Return Value: * Radio owner (objNull if not in external use) * * Example: * ["ACRE_PRC343_ID_1"] call acre_sys_external_fnc_getExternalRadioOwner * * Public: No */ params ["_radioId"]; private _owner = [_radioId] call EFUNC(sys_radio,getRadioObject); if !(_owner isKindOf "CAManBase") then { _owner = objNull; }; _owner #include "script_component.hpp" /* * Author: ACRE2Team * Retrieves the end user of a radio that is being used externally. * * Arguments: * 0: Unique radio identity * * Return Value: * End user (objNull if not in external use) * * Example: * ["ACRE_PRC343_ID_1"] call acre_sys_external_fnc_getExternalRadioUser * * Public: No */ params ["_radioId"]; [_radioId, "getState", "radioUsedExternally"] call EFUNC(sys_data,dataEvent) select 1 #include "script_component.hpp" /* * Author: ACRE2Team * Retrieves the external use status of a radio. * * Arguments: * 0: Unique radio identity * * Return Value: * Array with external use information * 0: Shared * 1: In external use * 2: Owner * 3: User * * Example: * ["ACRE_PRC343_ID_1"] call acre_sys_external_fnc_getExternalUseStatus * * Public: No */ params ["_radioId"]; private _isShared = [_radioId] call FUNC(isRadioShared); private _owner = objNull; private _user = objNull; private _isUsedExternally = [_radioId] call FUNC(isExternalRadioUsed); if (_isUsedExternally) then { _owner = [_radioId] call FUNC(getExternalRadioOwner); _user = [_radioId] call FUNC(getExternalRadioUser); }; [_isShared, _isUsedExternally, _owner, _user] #include "script_component.hpp" /* * Author: ACRE2Team * Returns a list of radios that are being shared by a unit. * * Arguments: * 0: Unit * * Return Value: * Array of ACRE2 unique radio IDs that are flagged as shared * * Example: * [cursorTarget] call acre_sys_external_fnc_getSharedExternalRadios * * Public: No */ params ["_unit"]; private _radios = [_unit] call EFUNC(sys_core,getGear); private _radioList = _radios select {_x call EFUNC(sys_radio,isUniqueRadio)}; if (!(alive _unit) || {captive _unit}) exitWith {_radioList}; _radioList select {[_x, "getState", "radioShared"] call EFUNC(sys_data,dataEvent)} #include "script_component.hpp" /* * Author: ACRE2Team * Initialises a radio with the additional states: isShared and isUsedExternally. * * Arguments: * 0: Unique radio identity * * Return Value: * None * * Example: * ["ACRE_PRC343_ID_1"] call acre_sys_external_fnc_initRadio * * Public: No */ params ["_radioId"]; [_radioId, false] call FUNC(allowExternalUse); [_radioId, "setState", ["radioUsedExternally", [false, objNull]]] call EFUNC(sys_data,dataEvent); // To prevent the GUI from being simultaneously opened [_radioId, "setState", ["radioGuiOpened", false]] call EFUNC(sys_data,dataEvent); #include "script_component.hpp" /* * Author: ACRE2Team * Checks if the player can perform external actions on shared radios. * * Arguments: * 0: Infantry unit * * Return Value: * Can interact with external radios * * Example: * [cursorTarget] call acre_sys_external_fnc_isExternalRadioAvailable * * Public: No */ params ["_target"]; // Check first distance to the unit if ((_target distance acre_player) > EXTERNAL_RADIO_MAXDISTANCE) exitWith {false}; // Action is available if the unit has shared radios. private _sharedRadios = [_target] call FUNC(getSharedExternalRadios); private _radiosInUse = _sharedRadios select {[_x] call FUNC(isExternalRadioUsed)}; // Of those radios that are in use, only the ones used by the player count { if (acre_player != [_x] call FUNC(getExternalRadioUser)) then { _sharedRadios deleteAt (_sharedRadios find _x); }; } forEach _radiosInUse; // If the player has external radios in use, the action to give or return radios should be also available (_sharedRadios isNotEqualTo []) || {ACRE_ACTIVE_EXTERNAL_RADIOS isNotEqualTo []} #include "script_component.hpp" /* * Author: ACRE2Team * Checks if a radio is externally available to the player. * * Arguments: * 0: Unique radio identity * 1: Radio owner * * Return Value: * Radio is available for external use * * Example: * ["ACRE_PRC343_ID_1"] call acre_sys_external_fnc_isExternalRadioAvailable * * Public: No */ /* TODO: * - Consider further corner cases. */ params ["_radioId", "_owner"]; // Check if actual owner of the radio is less than 2.0m away. if (((_owner distance acre_player) > EXTERNAL_RADIO_MAXDISTANCE) && {vehicle _owner != vehicle acre_player}) exitWith {false}; // Captive players are not allowed to use external radios if (captive acre_player) exitWith {false}; // Check if actual owner of the radio and the player are on the same vehicle. !((vehicle _owner != _owner) && {vehicle acre_player != acre_player} && {vehicle _owner != vehicle acre_player}) #include "script_component.hpp" /* * Author: ACRE2Team * Checks if a radio is flagged as being used by another unit. * * Arguments: * 0: Unique radio identity * * Return Value: * Radio is being externally used * * Example: * ["ACRE_PRC343_ID_1"] call acre_sys_external_fnc_isExternalRadioUsed * * Public: No */ params ["_radioId"]; [_radioId, "getState", "radioUsedExternally"] call EFUNC(sys_data,dataEvent) select 0 #include "script_component.hpp" /* * Author: ACRE2Team * Checks if a radio is shared to other players. * * Arguments: * 0: Unique radio identity * * Return Value: * Radio is shared and ready for external use * * Example: * ["ACRE_PRC343_ID_1"] call acre_sys_external_fnc_isRadioShared * * Public: No */ params ["_radioId"]; [_radioId, "getState", "radioShared"] call EFUNC(sys_data,dataEvent) #include "script_component.hpp" /* * Author: ACRE2Team * Generates a list of actions for radios that are being shared by a unit. * * Arguments: * 0: Unit with a shared radio * * Return Value: * Array of actions * * Example: * [cursorTarget] call acre_sys_external_fnc_listChildrenActions * * Public: No */ params ["_target"]; private _actions = []; private _sharedRadios = [_target] call FUNC(getSharedExternalRadios); // Add external radios in order to be able to "give" them to other players { _sharedRadios pushBackUnique _x; } forEach ACRE_ACTIVE_EXTERNAL_RADIOS; // Add player's radios that are shared private _ownSharedRadios = [acre_player] call FUNC(getSharedExternalRadios); { _sharedRadios pushBackUnique _x; } forEach _ownSharedRadios; { private _owner = ""; if (_x in ACRE_ACTIVE_EXTERNAL_RADIOS) then { _owner = format [" (%1)", name ([_x] call FUNC(getExternalRadioOwner))]; }; if (_x in _ownSharedRadios) then { _owner = format [" (%1)", name acre_player]; }; private _baseRadio = [_x] call EFUNC(api,getBaseRadio); private _item = ConfigFile >> "CfgWeapons" >> _baseRadio; private _displayName = getText (_item >> "displayName") + _owner; private _currentChannel = [_x] call EFUNC(api,getRadioChannel); _displayName = format [localize ELSTRING(ace_interact,channelShort), _displayName, _currentChannel]; private _picture = getText (_item >> "picture"); if ([_x, acre_player] call FUNC(checkListChildrenActions)) then { private _action = [_x, _displayName, _picture, {}, {true}, {_this call FUNC(childrenActions)}, [_x]] call ace_interact_menu_fnc_createAction; _actions pushBack [_action, [], _target]; }; } forEach _sharedRadios; _actions #include "script_component.hpp" /* * Author: ACRE2Team * Handles death of unit, primarily for handling local player death. External radios are returned to the original owner. * * Arguments: * 0: Unit * * Return Value: * Handled * * Example: * [player] call acre_sys_external_fnc_onPlayerKilled * * Public: No */ params ["_unit"]; if (_unit == acre_player) then { // All external radios in use are now returned to the owner { private _owner = [_x] call FUNC(getExternalRadioOwner); [_x, _owner] call FUNC(stopUsingExternalRadio); } forEach ACRE_ACTIVE_EXTERNAL_RADIOS; }; true #include "script_component.hpp" /* * Author: ACRE2Team * Check if a given action is available for a specific radio external radio. * * Arguments: * 1: Unique radio ID * * Return Value: * Action is available * * Example: * ["ACRE_PRC_343_ID_1"] call acre_sys_external_fnc_radioCheckChildrenActions * * Public: No */ params ["_radioId"]; if (_radioId in ACRE_ACTIVE_EXTERNAL_RADIOS) exitWith {false}; vehicle acre_player == acre_player #include "script_component.hpp" /* * Author: ACRE2Team * Start using an external radio. * * Arguments: * 0: Unique radio identity * 1: End user * * Return Value: * None * * Example: * ["ACRE_PRC343_ID_1", acre_player] call acre_sys_external_fnc_startUsingExternalRadio * * Public: No */ params ["_radioID", "_endUser"]; private _owner = [_radioId] call FUNC(getExternalRadioOwner); private _baseRadio = [_radioId] call EFUNC(api,getBaseRadio); private _displayName = getText (ConfigFile >> "CfgWeapons" >> _baseRadio >> "displayName"); // Do not flag as being externally used if it is already so (action give) if !([_radioId] call FUNC(isExternalRadioUsed)) then { [_radioId, "setState", ["radioUsedExternally", [true, _endUser]]] call EFUNC(sys_data,dataEvent); // Handle remote owner private _message = format [localize LSTRING(hintTakeOwner), _endUser, _displayName]; [QGVAR(startUsingRadioLocal), [_message, _radioId], _owner] call CBA_fnc_targetEvent; }; // Add the radio to the player ACRE_ACTIVE_EXTERNAL_RADIOS pushBackUnique _radioId; // Set it as active radio. [_radioId] call EFUNC(api,setCurrentRadio); [[ICON_RADIO_CALL], [format [localize LSTRING(hintTake), _displayName, name _owner]], true] call CBA_fnc_notify; #include "script_component.hpp" /* * Author: ACRE2Team * Stop using an external radio, either returning it to the owner or giving it to another player. If target * is skipped, a default action to return to the owner is taken. * * Arguments: * 0: Unique radio identity * 1: New end user/original owner * * Return Value: * None * * Example: * ["ACRE_PRC343_ID_1", cursorTarget] call acre_sys_external_fnc_stopUsingExternalRadio * * Public: No */ params ["_radioId", "_target"]; private _owner = [_radioId] call FUNC(getExternalRadioOwner); ACRE_ACTIVE_EXTERNAL_RADIOS = ACRE_ACTIVE_EXTERNAL_RADIOS - [_radioId]; [_radioId] call EFUNC(sys_radio,stopUsingRadio); private _baseRadio = [_radioId] call EFUNC(api,getBaseRadio); private _displayName = getText (ConfigFile >> "CfgWeapons" >> _baseRadio >> "displayName"); [[ICON_RADIO_CALL], [format [localize LSTRING(hintReturn), _displayName, name _owner]], true] call CBA_fnc_notify; if (_target == _owner) then { // Handle remote owner private _message = format [localize LSTRING(hintReturnOwner), name ([_radioId] call FUNC(getExternalRadioUser)), _displayName]; [QGVAR(stopUsingRadioLocal), [_message, _radioId], _owner] call CBA_fnc_targetEvent; // Give radio back to the owner [_radioId, "setState", ["radioUsedExternally", [false, objNull]]] call EFUNC(sys_data,dataEvent); } else { // Show a hint to the actual owner that the radio was given to another player private _message = format [localize LSTRING(hintGiveOwner), name ([_radioId] call FUNC(getExternalRadioUser)), _displayName, name _target]; [QGVAR(giveRadioLocal), [_message, _radioId], _owner] call CBA_fnc_targetEvent; // Give radio to another player [QGVAR(giveRadioAction), [_radioId, _target], _target] call CBA_fnc_targetEvent; }; #define COMPONENT sys_external #define COMPONENT_BEAUTIFIED External Radios #include "\idi\acre\addons\main\script_mod.hpp" // #define DEBUG_MODE_FULL // #define DISABLE_COMPILE_CACHE // #define ENABLE_PERFORMANCE_COUNTERS #ifdef DEBUG_ENABLED_SYS_EXTERNAL #define DEBUG_MODE_FULL #endif #ifdef DEBUG_SETTINGS_SYS_EXTERNAL #define DEBUG_SETTINGS DEBUG_SETTINGS_SYS_EXTERNAL #endif #include "\idi\acre\addons\main\script_macros.hpp" #define EXTERNAL_RADIO_MAXDISTANCE 2.0 Shared Radios Radios compartidas Geteilte Funkgeräte 無線機を共有 Общие рации Udostępnione radia 共用無線電 共用无线电 무전기가 공유됨 Rádios Compartilhados Radio Condivise Radios partagées Share Compartir Teilen 共有 Передать Udostępnij 共用 共用 공유 Compartilhar Condividi Partager Unshare No compartir Nicht teilen 共有解除 Забрать Wył. 取消共用 取消共用 공유 해제 Descompartilhar Non condividere Ne plus partager Take Handset ハンドセットを取る 拿起聽筒 拿起听筒 헤드셋 얻기 Pegar Aparelho Weź słuchawkę Prendi cuffia Coger transmisor Prendre le combiné Handteil nehmen Взять трубку Take Headset Coger auriculares Kopfhörer nehmen ヘッドセットを取る Взять наушники Weź słuchawki 拿起耳機 拿起耳机 헤드셋 얻기 Pegar Fones Prendi cuffia Prendre le casque Return Handset ハンドセットを戻す 放回聽筒 放回听筒 헤드셋 돌려놓기 Retornar Aparelho Odłóż słuchawkę Restituisci cuffia Devolver transmisor Rendre le combiné Handteil zurückgeben Вернуть трубку Return Headset Devolver auriculares Kopfhörer zurückgeben ヘッドセットを戻す Вернуть наушники Odłóż słuchawki 放回耳機 放回耳机 헤드셋 돌려놓기 Retornar Fones Restituisci cuffia Rendre le casque Give Handset ハンドセットを渡す 給予聽筒 给予听筒 헤드셋 주기 Dar Aparelho Podaj słuchawkę Passa cuffie Dar transmisor Donner le combiné Handteil geben Дать трубку Give Headset Dar auriculares Kopfhörer geben ヘッドセットを渡す Дать наушники Podaj słuchawki 給予耳機 给予耳机 헤드셋 주기 Dar Fones Passa cuffie Donner le casque %1 gave your %2 to %3 %1 は %2 を %3 へ渡しました %1把你的%2交給%3 %1把你的%2交给%3 %1은 %3에게 %2를 주었다 %1 deu seu %2 para %3 %1 podał twoje %2 do %3 %1 ha dato il tuo %2 a %3 %1 ha dado tu %2 a %3 %1 a donné votre %2 à %3. %1 gab dein %2 an %3 %1 передал вашу %2 %3 Stop using %1 from %2 %1 を %2 で使用停止する Перестать использовать %1 из %2 Przestałeś używać %1 od %2 停止使用%2的%1 停止使用%2的%1 %2의 %1을 사용중지 Para de usar %1 de %2 Smetti di usare %1 da %2 Deja de usar %1 de %2 Arrêter d'utiliser %1 de %2 %1 von %2 nicht länger benutzen %1 stopped using your %2 %1 は %2 を使用停止しました %1停止使用你的%2 %1停止使用你的%2 %1가 %2의 사용을 중지함 %1 parou de usar seu %2 %1 przestał używać twojego %2 %1 ha smesso di usare il tuo %2 %1 ha dejado de usar tu %2 %1 a arrêté d'utiliser votre %2. %1 hat aufgehört dein %2 zu nutzen %1 прекратил использовать вашу %2 Start using %1 from %2 %1 を %2 から使用する Начать использовать %1 из %2 Używasz %1 od %2 開始使用%2的%1 开始使用%2的%1 %2의 %1을 사용시작 Começar a usar %1 de %2 Inizia ad usare %1 da %2 Usa %1 de %2 Commencer à utiliser %1 de %2 Beginne %1 von %2 zu nutzen %1 started using your %2 %1 は %2 を使い始めました %1開始使用你的%2 %1开始使用你的%2 %1가 %2의 사용을 시작함 %1 começou a usar seu %2 %1 używa twojego %2 %1 ha iniziato ad usare il tuo %2 %1 está usando tu %2 %1 a commencé à utiliser votre %2. %1 benutzt jetzt dein %2 %1 начал использовать вашу %2 #include "script_component.hpp" [FUNC(externalRadioPFH), 0.91, []] call CBA_fnc_addPerFrameHandler; if (!hasInterface) exitWith {}; [QGVAR(startUsingRadioLocal), { params ["_message", "_radioId"]; // Manpack radios can also be used by the owner if they are not rack radios if ([_radioId] call EFUNC(sys_radio,isManpackRadio) && ([_radioId] call EFUNC(sys_rack,getRackFromRadio) == "")) then { ACRE_EXTERNALLY_USED_MANPACK_RADIOS pushBackUnique _radioId; } else { // fnc_stopUsingRadio cannot be used here since radio is in player's inventory // If it is the active radio if (ACRE_ACTIVE_RADIO isEqualTo _radioId) then { // Otherwise cleanup if (ACRE_ACTIVE_RADIO == ACRE_BROADCASTING_RADIOID) then { // Simulate a key up event to end the current transmission [] call EFUNC(sys_core,handleMultiPttKeyPressUp); }; // Switch active radio, but first reset it ACRE_ACTIVE_RADIO = ""; ACRE_ACTIVE_RADIO = ([] call EFUNC(sys_data,getPlayerRadioList)) select 0; }; ACRE_EXTERNALLY_USED_PERSONAL_RADIOS pushBackUnique _radioId; }; [[ICON_RADIO_CALL], [_message]] call CBA_fnc_notify; }] call CBA_fnc_addEventHandler; [QGVAR(stopUsingRadioLocal), { params ["_message", "_radioId"]; // Manpack radios can also be used by the owner if they are not rack radios if ([_radioId] call EFUNC(sys_radio,isManpackRadio) && ([_radioId] call EFUNC(sys_rack,getRackFromRadio) == "")) then { ACRE_EXTERNALLY_USED_MANPACK_RADIOS = ACRE_EXTERNALLY_USED_MANPACK_RADIOS - [_radioId]; } else { ACRE_EXTERNALLY_USED_PERSONAL_RADIOS = ACRE_EXTERNALLY_USED_PERSONAL_RADIOS - [_radioId]; }; [[ICON_RADIO_CALL], [_message], true] call CBA_fnc_notify; }] call CBA_fnc_addEventHandler; [QGVAR(giveRadioLocal), { params ["_message"]; [[ICON_RADIO_CALL], [_message], true] call CBA_fnc_notify; }] call CBA_fnc_addEventHandler; [QGVAR(giveRadioAction), {_this call FUNC(startUsingExternalRadio)}] call CBA_fnc_addEventHandler; #include "script_component.hpp" ADDON = false; PREP_RECOMPILE_START; #include "XEH_PREP.hpp" PREP_RECOMPILE_END; ADDON = true; PREP(allowExternalUse); PREP(externalRadioPFH); PREP(getExternalRadioOwner); PREP(getExternalRadioUser); PREP(getExternalUseStatus); PREP(getSharedExternalRadios); PREP(initRadio); PREP(isExternalRadioAvailable); PREP(isExternalRadioUsed); PREP(isRadioShared); PREP(onPlayerKilled); PREP(startUsingExternalRadio); PREP(stopUsingExternalRadio); // ACE interaction PREP(checkListChildrenActions); PREP(checkReturnGive); PREP(childrenActions); PREP(listChildrenActions); PREP(radioCheckChildrenActions); PREP(isExternalActionAvailable); #include "script_component.hpp" #include "XEH_PREP.hpp" L'!F~McOAn