|
|
| (54 intermediate revisions by 5 users not shown) |
| Line 1: |
Line 1: |
| [[Category:Arma 3: Remote Execution]]
| | {{RV|type=command |
| [[Category:Scripting_Commands_Arma_3]]
| |
| [[Category:Arma_3:_New_Scripting_Commands_List]]
| |
|
| |
|
| | |game1= arma3 |
| | |version1= 1.50 |
|
| |
|
| {{Command|Comments=
| | |gr1= Multiplayer |
| ____________________________________________________________________________________________
| |
|
| |
|
| | arma3 |Game name= | | |descr= [[Scheduler|Unscheduled]] version of [[remoteExec]]. The only difference between [[remoteExec]] and [[remoteExecCall]] is that [[remoteExecCall]] will run '''functions''' in [[Scheduler#Unscheduled Environment|unscheduled environment]]. |
| |1.50|Game version= | | {{Feature|important| |
| |gr1 = Multiplayer |GROUP1= | | The "Call" in [[remoteExecCall]] only means that the remote execution will take place in [[Scheduler#Unscheduled Environment|unscheduled environment]] and does '''not''' mean it will happen right away (see {{Link|#Example 3}}).}} |
| ____________________________________________________________________________________________
| |
|
| |
|
| | Asks the server to execute the given function or script command on the given target machine(s). Execution always takes place in the [[Scheduler#Unscheduled_Environment|unscheduled environment]]; suspension is not allowed. | | |s1= see [[remoteExec]] |
|
| |
|
| {{Informative|Just like [[remoteExec]], [[remoteExecCall]] can be used in SP; the behaviour is the same as in MP.}}
| | |p1= see [[remoteExec]] |
|
| |
|
| {{Important|The '''Call''' in [[remoteExecCall]] does not mean that the execution of the remote executed function / command will happen right away:
| | |r1= see [[remoteExec]] |
| <code>[[remoteExecCall]] ["fnc1"]; [[call]] fnc2; {{cc|It is possible that fnc2 is executed before fnc1.}}</code>
| |
| <code>[[call]] fnc1; [[call]] fnc2; {{cc|fnc2 will always be executed after fnc1.}}</code>
| |
| It just means that the execution of the function will take place in the [[Scheduler#Unscheduled_Environment|unscheduled environment]].}}
| |
|
| |
|
| {{Informative|The direct execution of [[call]] or [[spawn]] via [[remoteExecCall]] (or [[remoteExec]]) should be avoided to prevent issues in cases where the remote execution of [[call]] or [[spawn]] is blocked by [[Arma_3:_CfgRemoteExec|CfgRemoteExec]]. Instead it is recommended to create a function which is then excecuted by [[remoteExecCall]] (or [[remoteExec]]).}}
| | |x1= <sqf>["hello"] remoteExec ["hint"]; // runs unscheduled |
| | ["hello"] remoteExecCall ["hint"]; // no difference at all</sqf> |
|
| |
|
| Read [[Arma_3:_Remote_Execution|Arma 3: Remote Execution]] for more information about usage, security features and advanced JIP techniques.
| | |x2= <sqf>["my message"] remoteExec ["BIS_fnc_infoText"]; // correct |
| |DESCRIPTION=
| | ["my message"] remoteExecCall ["BIS_fnc_infoText"]; // wrong - BIS_fnc_infoText needs a scheduled environment, see its spawn need</sqf> |
|
| |
|
| | params [[remoteExecCall]] [functionName, targets, JIP] |SYNTAX= | | |x3= <sqf>remoteExecCall ["fnc1"]; |
| | call fnc2; // fnc1 may or may not be executed after fnc2 |
|
| |
|
| |p1= '''params''': [[Anything]] - The parameter(s) for the function / command specified in the '''functionName''' parameter.
| | call fnc1; |
| |PARAMETER1=
| | call fnc2; // fnc2 will be executed after fnc1</sqf> |
| | |
| |p2= '''[functionName, targets, JIP]''': [[Array]] <!-- This line is so useless... -->
| |
| |PARAMETER2=
| |
| | |
| |p3= '''functionName''': [[String]] - Function or command name.<br>
| |
| While any function or command can be used here, only those defined in [[Arma_3:_CfgRemoteExec|CfgRemoteExec]] will actually be executed.
| |
| |PARAMETER3=
| |
| | |
| |p4= '''targets''' (Optional, default: 0):
| |
| * [[Number]] (See also: [[Multiplayer_Scripting#Machine_network_ID|Machine network ID]]) -
| |
| ** '''0:''' The function / command will be executed globally, i.e. on the server and every connected client, including the machine where [[remoteExecCall]] originated.
| |
| ** '''2:''' The function / command will only be executed on the server.
| |
| ** '''Other number:''' The function / command will be executed on the machine where [[clientOwner]] matches the given number.
| |
| ** '''Negative number:''' The effect is inverted: -2 means every client but not the server, -12 means the server and every client, except for the client where [[clientOwner]] returns 12.
| |
| * [[Object]] - The function / command will be executed where the given [[Object]] is [[local]].
| |
| * [[String]] - Interpreted as an [[Identifier]] (variable name). The function / command will be executed where the [[Object]] or [[Group]] identified by the variable with the provided name is [[local]].
| |
| * [[Side]] - The function / command will be executed on clients where the player is on the specified side.
| |
| * [[Group]] - The function / command will be executed on clients where the player is in the specified group.<br>In order to execute the function / command where the group is [[local]], use the [[groupOwner]] of the group: <tt>_myGroup [[remoteExecCall]] ["deleteGroup", [[groupOwner]] _myGroup];</tt>
| |
| * [[Array]] - Array of any of the types listed above. <!-- TODO: Does this mean "array of any combination of the types listed above" or "array of one of the types listed above"? -->
| |
| |PARAMETER4=
| |
| | |
| |p5= '''JIP''' (Optional, default: [[false]]):
| |
| <br> <!-- KEEP ALL <br> TAGS IN THIS SECTION WHERE THEY ARE OR THE FORMATTING BREAKS -->
| |
| * [[Boolean]] - If [[true]], a unique JIP ID is generated and the [[remoteExecCall]] statement is added to the JIP queue from which it will be executed for every JIP.
| |
| * [[String]] -
| |
| ** If the string is empty, it is interpreted as [[false]].
| |
| ** If the string is in format "[[Number]]:[[Number]]" (e.g. "0:0"), it is interpreted as a [[netId]] (see below).
| |
| ** Else the string is treated as a custom JIP ID and the [[remoteExecCall]] statement is added to the JIP queue, replacing statements that have the same JIP ID.
| |
| * [[Object]], [[Group]] or [[netId]] - The persistent execution of the [[remoteExecCall]] statement is attached to the given [[Object]] or [[Group]].<br>When the [[Object]] or [[Group]] is deleted, the [[remoteExecCall]] statement is automatically removed from the JIP queue.
| |
| | |
| See also '''Example 7''' on how to remove statements from the JIP queue.
| |
| | |
| |PARAMETER5=
| |
| | |
| |
| |
| * [[nil]] - In case of error.
| |
| * [[String]] - In case of success.
| |
| ** If the '''JIP''' parameter was [[false]] or an empty string, the return value is "".
| |
| ** If the '''JIP''' parameter was [[true]] or a custom JIP ID, the JIP ID is returned.
| |
| ** If the '''JIP''' parameter was an [[Object]], a [[Group]] or a [[netId]], the (corresponding) [[netId]] is returned.
| |
| |RETURNVALUE=
| |
| | |
| _________________________________________________________________________________________________________________
| |
| | |
| |s2= [[remoteExecCall]] [functionName, targets, JIP] |SYNTAX2=
| |
| | |
| |p21= '''[functionName, targets, JIP]''': [[Array]]|PARAMETER21=
| |
| | |
| |p22= '''functionName''': [[String]] - function or command name. <br>
| |
| While any function can be used, only commands and functions defined in [[CfgRemoteExec]] will be executed.
| |
| |PARAMETER22=
| |
| | |
| |p23= '''targets''' (Optional): [default: 0 = everyone]
| |
| * [[Number]]
| |
| **When 0, the function or command will be executed globally, i.e. on the server and every connected client, including the one where [[remoteExecCall]] was originated.
| |
| **When 2, it will be executed only on the [[isServer|server]].
| |
| **When 3, 4, 5... it will be executed on the client where [[clientOwner]] ID matches the given number.
| |
| **When number is negative, the effect is inverted. -2 means execute on every client but not the server. -12, for example, means execute on the server and every client, but not on the client where [[clientOwner]] ID is equal to 12.
| |
| * [[Object]] - the function will be executed only where unit is local
| |
| * [[String]] - the function will be executed only where object or group defined by the variable with passed name is local
| |
| * [[Side]] - the function will be executed only on clients where the player is on the specified side.
| |
| * [[Group]] - the function will be executed only on clients where the player is in the specified group. In order to execute the function where group is [[local]] pass owner of the group as param: <br><tt>_myGroup [[remoteExecCall]] ["deleteGroup", [[groupOwner]] _myGroup];</tt>
| |
| * [[Array]] - array of any of types listed above.
| |
| |PARAMETER23=
| |
| | |
| |p24= ''' JIP''' (Optional): [default: false]<br><br>
| |
| * [[String]] or [[Boolean]] - If [[true]], function generates a unique ID for the message and the message itself is added to the JIP queue and executed for every JIP. If a non-empty string is given, it is treated a custom ID of the message and the message itself is added to the JIP queue overriding any [[remoteExecCall]] message with the same ID. Otherwise, no ID is generated and no message is placed into the JIP queue. (see also Example 7 on how to remove previously set function from JIP queue)<br><br>
| |
| * [[Object]] or [[Group]] or [[netId]] - The persistent execution of the given [[remoteExecCall]] statement will be attached to the given [[Object]] or [[Group]], passed directly by reference or by their [[netId]]: <tt>_netId = "this is my car" [[remoteExecCall]] ["hint", 0, car];</tt> or <tt>_netId = "this is my car" [[remoteExecCall]] ["hint", 0, [[netId]] car];</tt>Upon success, the command will return [[netId]] of the used [[Object]] or [[Group]] or [[netId]]. When [[Object]] or [[Group]] is deleted and becomes [[objNull]] or [[grpNull]], the persistent [[remoteExecCall]] statement is automatically removed from JIP queue. Manual removal of the JIP statement could be done by passing either [[Object]], [[Group]] or [[netId]] as usual:<tt>[[remoteExecCall]] ["", car];</tt> or <tt>[[remoteExecCall]] ["", [[netId]] car];</tt>When JIP param is [[String]] in format "[[Number]]:[[Number]]", the string will be tested first whether or not it is the valid [[netId]] of an existing [[Object]] or [[Group]], and if not the execution will be aborted, if yes, that [[Object]] or [[Group]] will be used to set persistent execution.|PARAMETER24=
| |
| | |
| |p25= {{Informative| JIP mostly makes sense for messages doing changes local to client (not directly synchronized over the network). Otherwise, after remoteExec is executed, depending on the contents of the global JIP queue there is a chance a new message could be added to it, unnecessary increasing the number of messages sent to any newly connected client.
| |
| E.g. calling "..remoteExec ["setFuel"..]" is fine, however, calling "..remoteExec ["publicVariable",..]" is not.}} |PARAMETER25=
| |
| | |
| |p26= {{Warning| There could be '''only one JIP message with the same JIP ID in the JIP queue'''. This means that if one tries to [[remoteExecCall]] again with the existing JIP ID, the JIP message which is already in the JIP queue will be overwritten. Passing [[true]] for JIP param autogenerates unique ID, therefore adding new message in the JIP queue each time. All other options have potential to overwrite existing JIP message.}}|PARAMETER26=
| |
| | |
| |r2= [[Anything]] - Nil in case of error. [[String]] otherwise. If JIP is not requested this is an empty string, if JIP is requested, it is the JIP ID. See the topic [[Function#Return_Values|Function]] for more information. |RETURNVALUE2=
| |
| ____________________________________________________________________________________________
| |
|
| |
| |x1= <code>// runs hint "hello" on each connected client
| |
| "hello" [[remoteExecCall]] ["[[hint]]"]; </code> |Example1=
| |
| |x2= <code>// runs hint "hello" on first connected client
| |
| "hello" [[remoteExecCall]] ["[[hint]]", 3]; </code> |Example2=
| |
| | |
| |x3= <code>// runs hint "hello" everywhere but server
| |
| "hello" [[remoteExecCall]] ["[[hint]]", -2]; </code> |Example3=
| |
| |x4= <code>// runs hint "hello" everywhere but server, JIPs the message
| |
| // and returns e.g. "3_1" as a unique JIP id
| |
| myJipID = "hello" [[remoteExecCall]] ["[[hint]]", -2, [[true]]]; </code> |EXAMPLE4=
| |
| | |
| |x5= <code>// runs hint "hello" everywhere but server, JIPs the message under ID "some_JIP_ID"
| |
| // replacing any previous message with this ID in the JIP queue.
| |
| "hello" [[remoteExecCall]] ["[[hint]]", -2, "some_JIP_ID"]; </code> |EXAMPLE5=
| |
| | |
| |x6= <code>// runs "someFuncWithNoArgs" on each connected client
| |
| [[remoteExecCall]] ["someFuncWithNoArgs"]; </code> |EXAMPLE6=
| |
| | |
| |x7= <!-- This example is referenced in the Syntax section! -->
| |
| Remove statements from the JIP queue:
| |
| <code>[[remoteExecCall]] ["", "MyCustomJIPID"]; {{cc|The persistent statement with the JIP ID "MyCustomJIPID" is removed from the JIP queue.}}
| |
| [[remoteExecCall]] ["", MyObject]; {{cc|The persistent statement attached to MyObject is removed from the JIP queue.}}
| |
| </code> | |
| |EXAMPLE7=
| |
| | |
| |x8= <code>// all clients will have their ammo set to 1 for their current weapon
| |
| {[[player]] [[setAmmo]] [<nowiki/>[[primaryWeapon]] [[player]], 1];} [[remoteExecCall]] ["[[BIS_fnc_call|bis_fnc_call]]", 0]; </code> |EXAMPLE8=
| |
| |x9= <code>// Object obj will have its ammo set to 1 where it is local
| |
| [obj,<nowiki>[</nowiki>[[primaryWeapon]] obj, 1]<nowiki>]</nowiki> [[remoteExecCall]] ["[[setAmmo]]", obj]; </code> |EXAMPLE9=
| |
| | |
| |x10= <code>myJipID = "hello" [[remoteExecCall]] ["", 0];
| |
| [[if]] ([[isNil]] "myJipID") [[then]] { [[hint]] "empty function name is not allowed"; }; </code> |EXAMPLE10=
| |
| | |
| ____________________________________________________________________________________________
| |
| | |
| | [[remoteExec]], [[isRemoteExecuted]], [[isRemoteExecutedJIP]], [[remoteExecutedOwner]], [[canSuspend]], [[BIS_fnc_MP]], [[Arma_3_Remote_Execution|Remote Execution]] |SEEALSO=
| |
|
| |
|
| | |seealso= [[remoteExec]] [[remoteExecutedOwner]] [[isRemoteExecuted]] [[isRemoteExecutedJIP]] [[Arma 3: Remote Execution]] [[canSuspend]] [[BIS_fnc_MP]] |
| }} | | }} |
|
| |
|
| <!-- CONTINUE Notes -->
| |
|
| |
| <!-- DISCONTINUE Notes -->
| |
|
| |
| <!-- CONTINUE Notes -->
| |
| <dl class="command_description">
| |
| <dd class="notedate">Posted on July 16, 2015 - 09:17 (UTC)</dd>
| |
| <dt class="note">[[User:Killzone Kid|Killzone Kid]]</dt>
| |
| <dd class="note">
| |
| Removal of persistent call must be in the following format <no argument> [[remoteExecCall]] [<empty string>, <JIP id>]. For example:
| |
| <code>[[remoteExecCall]] ["", "5:8"];</code>
| |
| </dd>
| |
| </dl>
| |
| <!-- DISCONTINUE Notes -->
| |
|
| |
| <!-- CONTINUE Notes -->
| |
| <dl class="command_description">
| |
| <dd class="notedate">Posted on December 29, 2015 - 20:31 (UTC)</dd>
| |
| <dt class="note">[[User:AgentRevolution|AgentRev]]</dt>
| |
| <dd class="note">
| |
| [[remoteExec]] and [[remoteExecCall]] are currently filtered by BattlEye's remoteexec.txt, the string analyzed by BE is formatted the same way as the following example's output:
| |
| <code>[[format]] ["%1 %2", functionName, [[str]] params]</code>
| |
| If [[CfgRemoteExec]] <tt>class Functions</tt> is set to <tt>mode = 1;</tt>, the following remoteexec.txt exclusion can be used to safely allow all whitelisted *_fnc_* functions taking an array as parameter to go through:
| |
| <code>!="\w+?_fnc_\w+? \[[\S\s]*\]"</code>
| |
| Any attempt to exploit this exclusion using other RE methods like [[createUnit]] will run into "Error Missing ;" without any malicious code being executed. Mod makers should refrain from remote-executing raw commands from clients, as they require individual exclusions, and instead use *_fnc_* functions taking an array as parameter, which are covered by the above exclusion.
| |
| </dd>
| |
| </dl>
| |
| <!-- DISCONTINUE Notes -->
| |
|
| |
| <!-- CONTINUE Notes -->
| |
| <dl class="command_description">
| |
| <dd class="notedate">Posted on May 10, 2017 - 20:13 (UTC)</dd>
| |
| <dt class="note">[[User:Killzone Kid|Killzone Kid]]</dt>
| |
| <dd class="note">
| |
| To [[remoteExecCall]]:
| |
| <code>[[titleText]] ["Test Message", "PLAIN", 1];</code>
| |
| Use
| |
| <code><nowiki>[</nowiki>["Test Message", "PLAIN", 1]] [[remoteExecCall]] ["titleText"];</code>
| |
| </dd>
| |
| </dl>
| |
| <!-- DISCONTINUE Notes -->
| |
|
| |
|
| <!-- CONTINUE Notes -->
| | {{GameCategory|arma3|Remote Execution}} |
| <dl class="command_description">
| |
| <dd class="notedate">Posted on January 17, 2020 - 15:05 (UTC)</dd>
| |
| <dt class="note">[[User:Dscha|Dscha]]</dt>
| |
| <dd class="note">
| |
| To send/execute custom functions and pass arguments (in this case to every connected Client, except the dedicated server):<br>
| |
| <code>[<br> [10,0],<br> {<br> [[player]] [[setAmmo]] [<nowiki/>[[primaryWeapon]] [[player]], (_this select 0)];<br> [[player]] [[setDamage]] (_this select 1)];<br> }<br>] [[remoteExecCall]] ["call", -2]; </code><br>
| |
| </dd>
| |
| </dl>
| |
| <!-- DISCONTINUE Notes -->
| |
