Changes for page Mission Director Guide

Last modified by Klaus Meyer on 2025/03/31 16:39

From 32941.1 to 32940.1 From 32947.1 to 32946.1

From version 32946.1

edited by Daniel Turner
on 2023/08/22 18:43

Change comment: There is no comment for this version

To version 32941.1

edited by Daniel Turner
on 2023/08/22 17:10

Change comment: There is no comment for this version

Raw
Rendered

Summary

Page properties (3 modified, 0 added, 0 removed)

Details

Page properties

Title

@@ -1,1 +1,1 @@
--Mission Director Guide
++X4:X4 Documentation/X4 Game Design/0 General/Mission Director Guide

Parent

...	...	@@ -1,1 +1,0 @@
1		-X Rebirth Wiki.Modding support.WebHome

Content

@@ -1,6 +1,6 @@
  The Mission Director (MD) is a subsystem of the game and interprets mission scripts, which are written in an XML-based language. The Mission Director in X Rebirth and X4 is based on the MD in X3: Terran Conflict, with some major changes based on feedback from MD users.\\
--An introduction to the original MD can be found in the[[(% &text-decoration: underline;" %)Egosoft forums>>url:http://forum.egosoft.com/viewtopic.php?t=196971]](%%). There is also a PDF guide for the X3 Mission Director, which is partially used as a template for this document.
++An introduction to the original MD can be found in the[[(% style="color: rgb(0,0,153);text-decoration: underline;" %)Egosoft forums>>url:http://forum.egosoft.com/viewtopic.php?t=196971]](%%). There is also a PDF guide for the X3 Mission Director, which is partially used as a template for this document.
  This document is primarily supposed to be a guide for MD users (people who use the MD to develop missions or write other MD scripts), not for MD programmers (people who work on the MD engine in C++).
@@ -14,9 +14,9 @@
  MD scripts are not necessarily missions. An MD file can contain a part of a mission, multiple missions, or no mission at all, as the MD is used for more than just missions.
--MD files are XML files located in the game folder {{code}}md{{/code}}. All XML files in that folder are loaded at game start. The file names are irrelevant, since the internally used script names are read from the XML root nodes. However, it's recommended to keep file name and internal script name identical to avoid having to look up the names.
++MD files are XML files located in the game folder {{code}}md{{/code}}. All XML files in that folder are loaded at game start. The file names are irrelevant, since the internally used script names are read from the XML root nodes. However, itΓÇÖs recommended to keep file name and internal script name identical to avoid having to look up the names.
--To edit MD scripts, an XML editing tool is needed. Microsoft Visual Studio (if available) or [[(% &text-decoration: underline;" %)Microsoft Visual Web Developer>>url:http://www.microsoft.com/express/vwd/]](%%) (for free) are highly recommended because they have pretty good support for XML schemas (XSD). The provided Mission Director schema files help you create the XML file by displaying all available tags and attributes as you edit the XML.
++To edit MD scripts, an XML editing tool is needed. Microsoft Visual Studio (if available) or [[(% style="color: rgb(0,0,153);text-decoration: underline;" %)Microsoft Visual Web Developer>>url:http://www.microsoft.com/express/vwd/]](%%) (for free) are highly recommended because they have pretty good support for XML schemas (XSD). The provided Mission Director schema files help you create the XML file by displaying all available tags and attributes as you edit the XML.
  This functionality is only available if the schema files **md.xsd** and **common.xsd** are in the correct folder. If you are editing the XML in the game folder directly, all is well and the files are loaded from the libraries folder. However, if you are editing in a separate folder, copy those XSD files from the libraries folder directly into the folder where your XML files are located.
@@ -46,7 +46,7 @@
  In this section we will look at how to start the whole process by creating a new MD mission file and the basic steps in producing mission content with XML code. There will be a description of the key elements of the mission file.
--The XML root node of an MD file is called "mdscript" and looks like this:
++The XML root node of an MD file is called ΓÇ£mdscriptΓÇ¥ and looks like this:
  {{code language="xml"}}
  <?xml version="1.0" encoding="utf-8"?>
@@ -53,7 +53,7 @@
  <mdscript name="ScriptName" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="md.xsd">
  {{/code}}
--"ScriptName" is the name used for this script regardless of the file name. It **has to start with an upper case letter and must be unique** among all MD script names. It also should not contain spaces, so other MD scripts can use it as an identifier to access this script's contents easily.
++ΓÇ£ScriptNameΓÇ¥ is the name used for this script regardless of the file name. It **has to start with an upper case letter and must be unique** among all MD script names. It also should not contain spaces, so other MD scripts can use it as an identifier to access this scriptΓÇÖs contents easily.
  The only allowed sub-node of <mdscript> is <cues>, which can only contain <cue> sub-nodes:
@@ -86,7 +86,7 @@
  \\
--{{info}}There can be a delay between the activation and performing the actions if the <delay> tag is used. In this case, sub-cues will be enter the waiting state before the parent's actions are performed.{{/info}}
++{{info}}There can be a delay between the activation and performing the actions if the &lt;delay&gt; tag is used. In this case, sub-cues will be enter the waiting state before the parent's actions are performed.{{/info}}
  This is how a cue node looks like:
@@ -110,7 +110,7 @@
  **Non-event conditions** are checked either once or repeatedly in a fixed interval. They may be based on simple values or ranges, such as a particular in-game time having been reached or the player having a certain amount of money. They may also be based on more complex player information, such as what ships they own, whether the player is in a particular area or near a particular object.
--**Event conditions** are triggered when the corresponding event happens, such as the event that a particular object has been targeted, attacked or destroyed. All event nodes have the prefix "event_" so you can easily determine a condition type. After an event condition you can specify one or more non-event conditions, which will be checked additionally whenever the event happens. If a condition uses an event, it must be in the first sub-node of the <conditions> node. It is even possible to define multiple alternative events that should activate the cue. The first sub-node should be <check_any> in this case, so only one of its sub-conditions has to be met.
++**Event conditions** are triggered when the corresponding event happens, such as the event that a particular object has been targeted, attacked or destroyed. All event nodes have the prefix ΓÇ£event_ΓÇ¥ so you can easily determine a condition type. After an event condition you can specify one or more non-event conditions, which will be checked additionally whenever the event happens. If a condition uses an event, it must be in the first sub-node of the <conditions> node. It is even possible to define multiple alternative events that should activate the cue. The first sub-node should be <check_any> in this case, so only one of its sub-conditions has to be met.
  Example for an event condition:
@@ -150,11 +150,11 @@
  If a cue has a <conditions> node without any event, it must have one of the attributes //**onfail**// or //**checkinterval**//.
--* Use //onfail// if the conditions should be checked only once. The possible attribute values are "//cancel//" and "//complete//". If the conditions are met, the cue will activate and perform the cue actions. Otherwise it's a failure and the cue will be cancelled or completed, based on the onfail attribute. Typically //onfail="cancel"// is used to prevent any further action. //onfail="complete"// can be used to continue with the sub-cues even in case of failure (but skipping the current cue actions).\\
++* Use //onfail// if the conditions should be checked only once. The possible attribute values are ΓÇ£//cancel//ΓÇ¥ and ΓÇ£//complete//ΓÇ¥. If the conditions are met, the cue will activate and perform the cue actions. Otherwise it's a failure and the cue will be cancelled or completed, based on the onfail attribute. Typically //onfail="cancel"// is used to prevent any further action. //onfail="complete"// can be used to continue with the sub-cues even in case of failure (but skipping the current cue actions).\\
--* With //checkinterval//, you can specify a constant time interval between condition checks. The conditions will be checked regularly forever until they are met, unless the cue's state is changed explicitly by an external event.
++* With //checkinterval//, you can specify a constant time interval between condition checks. The conditions will be checked regularly forever until they are met, unless the cueΓÇÖs state is changed explicitly by an external event.
  Additionally, you can use the attribute **checktime** to set the time of the first condition check (also possible in combination with //onfail//). The //checktime// can be an expression with variables and is evaluated when the cue is enabled (when the condition checks would normally start ΓÇô for root cues that happens at game start, otherwise after the parent cue becomes active).
@@ -198,7 +198,7 @@
  <event_cue_completed cue="parent"/>
  {{/code}}
--<actions> is optional. Leaving it out may be useful if you only want to enable sub-cues after the cue's condition check. The state transition from active to complete will still take the <delay> node into account.
++<actions> is optional. Leaving it out may be useful if you only want to enable sub-cues after the cueΓÇÖs condition check. The state transition from active to complete will still take the <delay> node into account.
  Note that the MD script language is not designed as a programming language. The actions are performed in sequence, although they can be nested to form more complex structures. Loops and conditionals exist to some extent, but not necessarily in the sense that a programmer might expect. Analogously to <check_all> and <check_any>, you can use **<do_all>** to perform all the contained sub-node actions, and **<do_any>** to perform only one of them. <do_all> is particularly useful when nested in a <do_any>.
@@ -216,7 +216,7 @@
--{{info}}Messages printed with <debug_text> are usually only visible when the "scripts" debug filter is enabled, see Script debug output{{/info}}
++{{info}}Messages printed with &lt;debug_text&gt; are usually only visible when the ΓÇ£scriptsΓÇ¥ debug filter is enabled, see [[NULL|Script debug output]].{{/info}}
@@ -245,7 +245,7 @@
  </library>
  {{/code}}
--Although it is called library, it's basically just a cue that doesn't do anything. You can mix cues and libraries as you want, as root cues or sub-cues - the location within the file is unimportant. All that counts is the library name, which has to be unique within the MD script, like all other cue names.
++Although it is called library, itΓÇÖs basically just a cue that doesnΓÇÖt do anything. You can mix cues and libraries as you want, as root cues or sub-cues - the location within the file is unimportant. All that counts is the library name, which has to be unique within the MD script, like all other cue names.
  To use a library, use the attribute ref:
@@ -290,7 +290,7 @@
--So when writing the library, you don't have to worry about name confusion, just use the names of cues in your library and it will work as expected when the library is used. Names of cues that do not belong to the library will not be available in expressions (see Foo in the example above), however, names of other libraries in the file are available when referencing them in the ref attribute.
++So when writing the library, you donΓÇÖt have to worry about name confusion, just use the names of cues in your library and it will work as expected when the library is used. Names of cues that do not belong to the library will not be available in expressions (see Foo in the example above), however, names of other libraries in the file are available when referencing them in the ref attribute.
  Notes:
@@ -315,7 +315,7 @@
  </library>
  {{/code}}
--If a default value is supplied, the parameter is regarded as optional, otherwise it's required. When providing the actual parameters in a referencing cue, note that there is no <params> node:
++If a default value is supplied, the parameter is regarded as optional, otherwise itΓÇÖs required. When providing the actual parameters in a referencing cue, note that there is no <params> node:
  {{code language="xml"}}
  <cue name="Foo" ref="Lib">
@@ -324,7 +324,7 @@
  </cue>
  {{/code}}
--The values (including default values) can be variable expressions and will be evaluated when the cue is enabled, i.e. when it starts checking the conditions. They will be available to the cue as variables, using the parameter name with a ΓÇÿ$' prefix. In the example above, the variables $foo, $bar, and $baz would be created.
++The values (including default values) can be variable expressions and will be evaluated when the cue is enabled, i.e. when it starts checking the conditions. They will be available to the cue as variables, using the parameter name with a ΓÇÿ$ΓÇÖ prefix. In the example above, the variables $foo, $bar, and $baz would be created.
  {{code language="xml"}}
  <library name="Lib">
@@ -341,27 +341,27 @@
  = Instantiation =
--One of the possible cue attributes is //**instantiate**//. If you set it to true, this changes what happens when a cue's conditions are met. Normally, if a cue is not instantiated, the cue's actions are run (taking a delay node into account) and the cue is marked as completed. But with **instantiate'//, a// **copy of the cue** (and all its sub-cues) is made when the conditions are met, and it is this copy in which the actions are performed and it is the copy whose status is set to complete when they are finished - this means that the original cue (the so-called **static cue**) remains in the //waiting// state, and if the conditions are met again then the whole thing happens all over again.**
--\\An instantiating cue should only be used with conditions that are only going to be met once (or a fairly limited number of times), or with conditions that include an event condition. Instantiation should not be used in a cue which, say, just depends on the game time being greater than a specific value as this will result in a copy of the cue being made after each check interval, which could increase memory usage a lot. The most common use of an instantiated cue is in responding to events such as the player ship changing sector, to react every time that event happens.
++One of the possible cue attributes is //**instantiate**//. If you set it to true, this changes what happens when a cue's conditions are met. Normally, if a cue is (% style="color: rgb(0,0,0);text-decoration: underline;" %)not instantiated, the cue's actions are run (taking a delay node into account) and the cue is marked as completed. But with **instantiate'//, a// **copy of the cue** (and all its sub-cues) is made when the conditions are met, and it is this copy in which the actions are performed and it is the copy whose status is set to complete when they are finished - this means that the original cue (the so-called **static cue**) remains in the //waiting// state, and if the conditions are met again then the whole thing happens all over again.**
++\\An instantiating cue should only be used with conditions that are only going to be met once (or a fairly limited number of times), or with conditions that include an event condition. Instantiation should (% style="color: rgb(0,0,0);text-decoration: underline;" %)not be used in a cue which, say, just depends on the game time being greater than a specific value as this will result in a copy of the cue being made after each check interval, which could increase memory usage a lot. The most common use of an instantiated cue is in responding to events such as the player ship changing sector, to react every time that event happens.
  \\Instances that are created via //instantiate// are called **instantiated cues**. But sub-cues of instances are also instances (**sub-instances**) - they are created when they enter the waiting state. An instance is removed again (thereby freeing its memory) when it is complete or cancelled, and when all its instance sub-cues have been removed before. The simplest case is an instantiating cue with no sub-cues: The instance is created, the actions are performed, and the instance is removed immediately on completion. A pitfall could be an instance with a sub-cue that is forever in the waiting state (e.g. waiting for an event from an already destroyed object). It can never be removed, so you should clean up such a cue yourself, e.g. by cancelling it explicitly.
  == Cleaning up instances explicitly ==
--Cancelling a cue with **<cancel_cue>** also cancels all its sub-cues, and cancelling a static cue stops it from instantiating more cues - but it does not cancel its instances. Resetting a cue with **<reset_cue>** resets both sub-cues and instantiated cues, but has the (desired) side effect that condition checks will start again if the parent cue's state allows it. Even a sub-instance that has been reset can return to the //waiting// state. Resetting an instantiated cue will stop it forever, because it is not supposed to be in the //waiting// state (only its static cue is). Resetting will also induce the clean-up reliably, but keep in mind that this is not the case for instance sub-cues.
++Cancelling a cue with **<cancel_cue>** also cancels all its sub-cues, and cancelling a static cue stops it from instantiating more cues - but it does not cancel its instances. Resetting a cue with **<reset_cue>** resets both sub-cues and instantiated cues, but has the (desired) side effect that condition checks will start again if the parent cueΓÇÖs state allows it. Even a sub-instance that has been reset can return to the //waiting// state. Resetting an instantiated cue will stop it forever, because it is not supposed to be in the //waiting// state (only its static cue is). Resetting will also induce the clean-up reliably, but keep in mind that this is not the case for instance sub-cues.
--{{info body="<cancel_cue> and <reset_cue> only take effect after all remaining actions of the current cue are performed. So you can even safely cancel the cue that you are currently in (keyword "'''this'''") or any ancestor cue, and still perform more actions afterwards."/}}
++{{info body="&lt;cancel_cue&gt; and &lt;reset_cue&gt; only take effect after all remaining actions of the current cue are performed. So you can even safely cancel the cue that you are currently in (keyword ΓÇ£'''this'''ΓÇ¥) or any ancestor cue, and still perform more actions afterwards."/}}
  == Access to instances ==
--{{info}}This sub-section requires basic knowledge of script expressions.{{/info}}
++{{info}}This sub-section requires basic knowledge of [[NULL|script expressions]].{{/info}}
  In case of instances with sub-instances, you will often want to access a related instance from the current one. Like in the non-instance case, you can simply write the cue name in an expression to reference that cue. However, you should be aware of the pitfalls that are accompanied by this.
--When you use a cue name from the same script in an expression, it will always be resolved to some cue - usually a static cue, even if it is still in the disabled state, but it can also be an instance, if it is "related" to the current one.
++When you use a cue name from the same script in an expression, it will always be resolved to some cue - usually a static cue, even if it is still in the disabled state, but it can also be an instance, if it is ΓÇ£relatedΓÇ¥ to the current one.
  Related means that this cue and the referenced cue have a common ancestor instance, and the referenced cue is a direct (non-instantiated) descendant of that common ancestor.
@@ -374,11 +374,11 @@
  Example situations:
  * In the static tree: Cue names in expressions are always resolved to the static cues.
--* In the inst-2 tree: "SubBar" in an expression will be resolved to SubBar (inst 2).
--* In the inst-1 tree: "SubBar" in an expression will be resolved to SubBar (static) (!) because the SubBar child of Bar (inst 1) does not exist yet, or not any more.
--* In the inst-2a tree: "SubBaz" in an expression will be resolved to SubBaz (inst 2a)
--* In the inst-2a tree: "Bar" in an expression will be resolved to Bar (inst 2) because Foo (inst 2) is a common ancestor.
--* In the inst-2 tree: "SubBaz" in an expression will be resolved to SubBaz (static) (!) because SubBaz (inst 2a) is **not** a direct descendant of the common ancestor Foo (inst 2), instead Baz (inst 2a) has been instantiated.
++* In the inst-2 tree: ΓÇ£SubBarΓÇ¥ in an expression will be resolved to SubBar (inst 2).
++* In the inst-1 tree: ΓÇ£SubBarΓÇ¥ in an expression will be resolved to SubBar (static) (!) because the SubBar child of Bar (inst 1) does not exist yet, or not any more.
++* In the inst-2a tree: ΓÇ£SubBazΓÇ¥ in an expression will be resolved to SubBaz (inst 2a)
++* In the inst-2a tree: ΓÇ£BarΓÇ¥ in an expression will be resolved to Bar (inst 2) because Foo (inst 2) is a common ancestor.
++* In the inst-2 tree: ΓÇ£SubBazΓÇ¥ in an expression will be resolved to SubBaz (static) (!) because SubBaz (inst 2a) is **not** a direct descendant of the common ancestor Foo (inst 2), instead Baz (inst 2a) has been instantiated.
  In expressions, you can use the cue property **static** to access the static cue that instantiated a cue. This does not work for sub-cues of other cues, and the result is not necessarily a real static cue! In the example above, it would only work for cues with a dotted arrow pointing at them, and is resolved to the source of the arrow. In other cases the result is null.
@@ -394,16 +394,12 @@
  * **Conditions with results:** If the instantiating cue has conditions with results, those results are stored in variables - but in the variables of the static cue, not of the instance! So in the <actions> you have to access the variables via the **static **keyword:\\
--{{code language="xml"}}
--  <debug_text text="static.$foo"/>
--{{/code}}
--It may even be necessary to copy the variables over to the instance because the static variables can be overwritten by the next condition check:
--{{code language="xml"}}
--<set_value name="$foo" exact="static.$foo"/>
--{{/code}}
++{{code}}&lt;debug_text┬átext=&quot;static.$foo&quot;/&gt;{{/code}}(% style="color: rgb(0,0,255);text-decoration: none;" %)
++\\It may even be necessary to copy the variables over to the instance because the static variables can be overwritten by the next condition check:
++\\{{code}}&lt;set_value┬áname=&quot;$foo&quot;┬áexact=&quot;static.$foo&quot;/&gt;{{/code}}
--* **Resetting completed/cancelled instances:** As explained above, sub-instances are only created when needed (when going to the //waiting// state) and are destroyed when they are not needed any more (when they are completed or cancelled, including all sub-cues). There are cases in which you want to access cues that don't exist any more - it simply doesn't work. In some cases you are safe: You can be sure that all your ancestors exist, and instantiating cues won't be removed until they are cancelled. In some other cases you simply don't know and have to check if the instance is already (or still) there.
--* **Lifetime of instances:** Do not make assumptions about when an instance is removed! Just looking at it in the Debug Manager keeps it alive for the time being. So, sometimes you could still have a completed instance that wouldn't exist under other circumstances.
++* **Resetting completed/cancelled instances:** As explained above, sub-instances are only created when needed (when going to the //waiting// state) and are destroyed when they are not needed any more (when they are completed or cancelled, including all sub-cues). There are cases in which you want to access cues that donΓÇÖt exist any more - it simply doesnΓÇÖt work. In some cases you are safe: You can be sure that all your ancestors exist, and instantiating cues wonΓÇÖt be removed until they are cancelled. In some other cases you simply donΓÇÖt know and have to check if the instance is already (or still) there.
++* **Lifetime of instances:** Do not make assumptions about when an instance is removed! Just looking at it in the Debug Manager keeps it alive for the time being. So, sometimes you could still have a completed instance that wouldnΓÇÖt exist under other circumstances.
  = Expressions =
@@ -412,12 +412,12 @@
  * {{code}}0{{/code}} (integer number)
  * {{code}}0772{{/code}} (leading 0 means octal integer number)
  * {{code}}3.14159{{/code}} (floating point number)
--* {{code}}5e12{{/code}} (float in exponent notation, "times ten to the power of")
++* {{code}}5e12{{/code}} (float in exponent notation, ΓÇ£times ten to the power ofΓÇ¥)
  * {{code}}0xCAFE{{/code}} (hexadecimal integer number)
--{{info}}Since octal numbers are hardly ever used (usually unknowingly), the parser is will produce a warning if an octal number is encountered."{{/info}}
++{{info}}Since octal numbers are hardly ever used (usually unknowingly), the parser is will produce a warning if an octal number is encountered."{{info}}
@@ -429,11 +429,11 @@
--{{info}}Since expressions are written in XML attribute values, you have to use the single quotes inside the double quotes for the actual attribute value. To write characters like '''< > " &''' in an expression string (or anywhere else in an XML attribute value), you'll have to escape them as '''&lt; &gt; &quot; &amp;''' respectively. The backslash '''\''' can be used in strings for escape characters like in C/C++. Most important are '''\'''' for a single quote as part of the string, and '''\\''' for the backslash itself.{{/info}}
++{{info}}Since expressions are written in XML attribute values, you have to use the single quotes inside the double quotes for the actual attribute value. To write characters like '''&lt; &gt; &quot; &amp;''' in an expression string (or anywhere else in an XML attribute value), youΓÇÖll have to escape them as '''&amp;lt; &amp;gt; &amp;quot; &amp;amp;''' respectively. The backslash '''\''' can be used in strings for escape characters like in C/C++. Most important are '''\'''' for a single quote as part of the string, and '''\\''' for the backslash itself.{{/info}}
  == Numeric data types and suffixes ==
--Numbers can have a suffix that determines their numeric type. There are also numerical data types like "money" or "time" which can only be expressed by using an appropriate unit suffix:
++Numbers can have a suffix that determines their numeric type. There are also numerical data types like ΓÇ£moneyΓÇ¥ or ΓÇ£timeΓÇ¥ which can only be expressed by using an appropriate unit suffix:
  * {{code}}5000000000L{{/code}} (large integer)
  * {{code}}1f{{/code}} (floating point number, same as 1.0, just 1 would be an integer)
@@ -485,7 +485,7 @@
  == Operators ==
--You can build expressions by combining sub-expressions with operators. For Boolean operations, expressions are considered "false" if they are equal to zero, "true" otherwise. The following operators, delimiters, and constants are supported
++You can build expressions by combining sub-expressions with operators. For Boolean operations, expressions are considered ΓÇ£falseΓÇ¥ if they are equal to zero, ΓÇ£trueΓÇ¥ otherwise. The following operators, delimiters, and constants are supported
  (% style="margin-left: 0.0px;" %)
  (((
@@ -536,24 +536,24 @@
  |-|binary|{{code}}1 - 1{{/code}}|{{code}}0{{/code}}|Subtraction
  |
  lt
--\\< (<)|binary|
++\\&lt; (<)|binary|
  {{code}}1 lt 3{{/code}}
--\\{{code}}1 &lt; 3{{/code}}|{{code}}true{{/code}}|Less than
++\\{{code}}1 &amp;lt; 3{{/code}}|{{code}}true{{/code}}|Less than
  |
  le
--\\<=|binary|
++\\&lt;=|binary|
  {{code}}1 le 3{{/code}}
--\\{{code}}1 &lt;= 3{{/code}}|{{code}}true{{/code}}|Less than or equal to
++\\{{code}}1 &amp;lt;= 3{{/code}}|{{code}}true{{/code}}|Less than or equal to
  |
  gt
--\\> (>)|binary|
++\\&gt; (>)|binary|
  {{code}}1 gt 3{{/code}}
--\\{{code}}1 &gt; 3{{/code}}|{{code}}false{{/code}}|Greater than
++\\{{code}}1 &amp;gt; 3{{/code}}|{{code}}false{{/code}}|Greater than
  |
  ge
--\\>=|binary|
++\\&gt;=|binary|
  {{code}}1 ge 3{{/code}}
--\\{{code}}1 &gt;= 3{{/code}}|{{code}}false{{/code}}|Greater than or equal to
++\\{{code}}1 &amp;gt;= 3{{/code}}|{{code}}false{{/code}}|Greater than or equal to
  |(((
  =  =
  )))|binary|{{code}}1 + 1 == 2.0{{/code}}|{{code}}true{{/code}}|Equal to
@@ -573,7 +573,7 @@
  === Operator precedence rules ===
--You can group sub-expressions using parentheses, but if you don't, the following order of operations is applied, so that 5-1+2*3 == 10 as you would expect. The order is the same as in the table above, but there are operators with the same precedence - these are applied from left to right.
++You can group sub-expressions using parentheses, but if you donΓÇÖt, the following order of operations is applied, so that 5-1+2*3 == 10 as you would expect. The order is the same as in the table above, but there are operators with the same precedence - these are applied from left to right.
  * Unary operators: +, -, not, typeof, function-style operators (highest precedence)
  * Power operator: ^
@@ -591,7 +591,7 @@
  When a binary arithmetic operator is used on numbers of different types, they will be converted to a suitable output type. The resulting type depends on whether a unit data type is involved (types that are not plain integers or floats). The following cases may occur:
--* Null and something else: The null value will be interpreted as "0" of the other type.
++* Null and something else: The null value will be interpreted as ΓÇ£0ΓÇ¥ of the other type.
  * Two non-unit integers: The result will be an integer of the largest involved type.
  * Two non-unit numbers, not all integers: The result will be the largest involved float type.
  * Non-unit and unit: The result will be the unit type.
@@ -604,7 +604,7 @@
  * {{code}}(1 + 1)f{{/code}} ⟹ {{code}}2f{{/code}} ⟹ {{code}}2.0{{/code}}
  * {{code}}(1h) m / (180deg) i{{/code}} ⟹ {{code}}(3600s) m / (3.14rad) i{{/code}} ⟹ {{code}}3600m / 3{{/code}} ⟹ {{code}}1200m{{/code}}
--When converting to a non-default unit type, this means you interpret the number as in the given units: "{{code}}(1km + 500m)h{{/code}}" means that you interpret 1500m as 1500 hours, so the resulting value will be 1500x3600 seconds. (As stated above, the default unit for a length is metres.)
++When converting to a non-default unit type, this means you interpret the number as in the given units: ΓÇ£{{code}}(1km + 500m)h{{/code}}ΓÇ¥ means that you interpret 1500m as 1500 hours, so the resulting value will be 1500x3600 seconds. (As stated above, the default unit for a length is metres.)
  The division operation will be an integer division (rounding towards zero) if both operands are integers (see the example in the table above). So if you want to get a floating point result, you have to make sure that at least one of the operands is a floating point type.
@@ -622,12 +622,12 @@
  Some additional notes on Boolean operators (such as and, or, not, ==):
  * Of course a Boolean operation always results in true or false (integer 1 or 0).
--* Values of any type can be used as Boolean operands, e.g. for "and". They will be interpreted as "true" if they are **non-zero** or **non-numeric**.
++* Values of any type can be used as Boolean operands, e.g. for ΓÇ£andΓÇ¥. They will be interpreted as ΓÇ£trueΓÇ¥ if they are **non-zero** or **non-numeric**.
  * != and == can be used with any data types, even non-numeric ones. When comparing two numeric values, they are converted using the rules above. Values of non-numeric types are never equal to null, or to any other numbers.
--* "and" and "or" use short-circuit semantics: The right side of the operation can be skipped if the left side already determines the outcome of the operation
++* ΓÇ£andΓÇ¥ and ΓÇ£orΓÇ¥ use short-circuit semantics: The right side of the operation can be skipped if the left side already determines the outcome of the operation
  ** Example:{{code}} false and $foo{{/code}} ⟹ {{code}}false{{/code}} (the value of $foo is not checked at all)
  * Unlike != and ==, the comparison operators <, <=, >, >= are only supported **for numeric values**, **difficulty levels**, and **attention levels**. Comparing other non-numeric values will result in an error and an undefined result.
--* <, <=, >, >= cannot be used in XML directly, so lt, le, gt, ge are provided as alternatives. In some cases you won't have to use them, though - using [[range checks>>MediaWiki.NULL]] with additional XML attributes can be more readable.
++* <, <=, >, >= cannot be used in XML directly, so lt, le, gt, ge are provided as alternatives. In some cases you wonΓÇÖt have to use them, though - using [[range checks>>MediaWiki.NULL]] with additional XML attributes can be more readable.
@@ -643,7 +643,7 @@
  See also the section about [[value properties>>MediaWiki.NULL]].
--Instead of ΓÇÿ%1 %2 %3', you can also use ΓÇÿ%s %s %s', which is also compatible with Lua string formatting in the UI system. However, this should only be used if you are sure that the order is the same in all supported languages. If you want to make translators aware that they can change the order of parameters, you should prefer '%1 %2 %3'.
++Instead of ΓÇÿ%1 %2 %3ΓÇÖ, you can also use ΓÇÿ%s %s %sΓÇÖ, which is also compatible with Lua string formatting in the UI system. However, this should only be used if you are sure that the order is the same in all supported languages. If you want to make translators aware that they can change the order of parameters, you should prefer '%1 %2 %3'.
  \\To get a percent character in the result string, use '%%' in the format string.
  \\\\\\If you need a more sophisticated method for text substitution, try **<substitute_text>**. See the XML schema documentation for this script action.
  \\**[New as of X Rebirth 4.0]**
@@ -656,12 +656,12 @@
  Additional remarks:
  * The "," and "." formatting modifiers only apply to numbers. They are ignored if used on values of other types.
--*  If "," is used without "." then any fractional digits are discarded.
++* ┬áIf "," is used without "." then any fractional digits are discarded.
  * "." must be followed by a single digit (0-9). In case of ".0" any fractional digits are discarded (rounding towards zero, not half away from zero).
--{{info body="There are also special methods to [[NULL|format money values and time values]] using the "formatted" property."/}}
++{{info body="There are also special methods to [[NULL|format money values and time values]] using the &quot;formatted&quot; property."/}}
@@ -673,19 +673,19 @@
  Another example for a non-numeric value is a list: It is an ordered collection of other arbitrary values (called array or vector in other languages). It can be constructed within an expression using the [[~[~] syntax>>MediaWiki.NULL]]. It may also be generated by special actions and conditions, and there are actions that can [[insert or remove values>>MediaWiki.NULL]].
--A list can contain values of arbitrary data types, even mixed in the same list - so a list can actually contain other lists. However, some of the things that you can do with lists require that all contained elements are of a certain type. The contents of a list can be accessed via properties, see the section about [[value properties>>MediaWiki.NULL]]. Lists can be empty, these are written as "[ ]".
++A list can contain values of arbitrary data types, even mixed in the same list - so a list can actually contain other lists. However, some of the things that you can do with lists require that all contained elements are of a certain type. The contents of a list can be accessed via properties, see the section about [[value properties>>MediaWiki.NULL]]. Lists can be empty, these are written as ΓÇ£[ ]ΓÇ¥.
--{{info}}When accessing a list's elements, the numbering is '''1-based''', so the first element has number 1. This is intuitive but different from 0-based numbering in most programming languages."{{/info}}
++{{info}}When accessing a listΓÇÖs elements, the numbering is '''1-based''', so the first element has number 1. This is intuitive but different from 0-based numbering in most programming languages."{{/info}}
  Lists are stored in variables as references, so multiple variables can refer to the same **shared list**: If you change a shared list through a variable, e.g. by changing the value of an element, you change it as well for all other variables. However, the operators == and != can also be used on two distinct lists to compare their elements.
--{{info}}When using <remove_from_list/>, be aware that all elements are checked and potentially removed during the action. Do not provide this action with a index lookup of that list as it may become out of bounds.
++{{info}}When using &lt;remove_from_list/&gt;, be aware that all elements are checked and potentially removed during the action. Do not provide this action with a index lookup of that list as it may become out of bounds.
--Bad usage attempting to remove the last element of the list: <remove_from_list name="$List" exact="$List.{$List.count}"/>
++Bad usage attempting to remove the last element of the list: &lt;remove_from_list name=&quot;$List&quot; exact=&quot;$List.{$List.count}&quot;/&gt;
--If you know the index, simply use <remove_value/> e.g. <remove_value name="$List.{$List.count}"/>{{/info}}
++If you know the index, simply use &lt;remove_value/&gt; e.g. &lt;remove_value name=&quot;$List.{$List.count}&quot;/&gt;"{{/info}}
@@ -707,15 +707,15 @@
  These restrictions only apply to the keys, there are no restrictions for values that you assign to them. For example:
--* {{code language="xml"}}table[]{{/code}} ⟹ creates an empty table
--* {{code language="xml"}}table[{0} = null]{{/code}} ⟹ creates a table that maps the number 0 to null\\
++* {{code}}table[]{{/code}} ⟹ creates an empty table
++* {{code}}table[{0} = null]{{/code}} ⟹ creates a table that maps the number 0 to null\\
--* {{code language="xml"}}table[{'$foo'} = 'bar']{{/code}} ⟹ a table that maps the string '$foo' to the string 'bar'
--* {{code language="xml"}}table[$foo = 'bar']{{/code}} ⟹ exactly the same, just a shorter notation for string keys
--* {{code language="xml"}}table[foo = 'bar']{{/code}} ⟹ error, 'foo' does not start with a '$'
--* {{code language="xml"}}table[{1} = [], {2} = table[]] {{/code}} ⟹ a table that maps 1 to an empty list and 2 to an empty table\\
++* {{code}}table[{'$foo'} = 'bar']{{/code}} ⟹ a table that maps the string '$foo' to the string 'bar'
++* {{code}}table[$foo = 'bar']{{/code}} ⟹ exactly the same, just a shorter notation for string keys
++* {{code}}table[foo = 'bar']{{/code}} ⟹ error, 'foo' does not start with a '$'
++* {{code}}table[{1} = [], {2} = table[]] {{/code}} ⟹ a table that maps 1 to an empty list and 2 to an empty table\\
@@ -727,9 +727,9 @@
  == Value properties ==
--Properties are a crucial concept in script expressions. In the previous sections you have seen mostly constant expressions, which are already evaluated when they are parsed at game start. For reading and writing variables and evaluating the game's state, properties are used.
++Properties are a crucial concept in script expressions. In the previous sections you have seen mostly constant expressions, which are already evaluated when they are parsed at game start. For reading and writing variables and evaluating the gameΓÇÖs state, properties are used.
--Numbers don't have any properties. Lists, for example, have quite a few of them: You can access the number of elements; and each element is also a property of the list. A ship can have properties like its name, the ship class, its position etc.
++Numbers donΓÇÖt have any properties. Lists, for example, have quite a few of them: You can access the number of elements; and each element is also a property of the list. A ship can have properties like its name, the ship class, its position etc.
  You can imagine properties as key/value pairs in an associative mapping: You pass the key, and you get the value as result. For example, the list [42, null, 'text'] has the following mapping:
@@ -749,7 +749,7 @@
--In most cases the property key is a fixed string, like "name" or "class". You can write this like above:
++In most cases the property key is a fixed string, like ΓÇ£nameΓÇ¥ or ΓÇ£classΓÇ¥. You can write this like above:
  * {{code}}[42].{'count'}{{/code}}
  * {{code}}$ship.{'name'}{{/code}}
@@ -767,7 +767,7 @@
--(In this case, $ship is a variable. All variables start with a "$", so they cannot be confused with keywords.)
++(In this case, $ship is a variable. All variables start with a ΓÇ£$ΓÇ¥, so they cannot be confused with keywords.)
  A list has even more properties:
@@ -781,7 +781,7 @@
  * {{code}}[1, 6, 8].average{{/code}} ⟹ 5
--**indexof'** is followed by another property, and the index of the first occurence of that key in the list is returned, or 0 if it's not in the list
++**indexof'** is followed by another property, and the index of the first occurence of that key in the list is returned, or 0 if itΓÇÖs not in the list
  * {{code}}[1, 6, 8].indexof.{8}{{/code}} ⟹ 3
@@ -816,7 +816,7 @@
  {{{===}}}
--If you look up a property that does not exist, there will be an error, and the result will be null. To test whether a property exists, you can append a question mark "?" to the lookup, which yields true or false:
++If you look up a property that does not exist, there will be an error, and the result will be null. To test whether a property exists, you can append a question mark ΓÇ£?ΓÇ¥ to the lookup, which yields true or false:
  * {{code}}$list.{5}{{/code}} ⟹ The fifth element of a list - however, if $list has less than 5 elements (and if it's also not a table with the key 5), there will be an error
  * {{code}}$list.{5}?{{/code}} ⟹ true if $list exists and has the property 5, false otherwise
@@ -829,7 +829,7 @@
  * {{code}}$list{{/code}} ⟹ The value stored under the name $list, or an error if there is no such variable
  * {{code}}$list?{{/code}} ⟹ true if the variable exists, false otherwise
--To look up the value of a property although it may not exist, you can use the at-sign "@" as prefix:
++To look up the value of a property although it may not exist, you can use the at-sign ΓÇ£@ΓÇ¥ as prefix:
  * {{code}}@$list.{5}{{/code}} ⟹ The result of the $list lookup if $list exists and has the property 5, otherwise null (without error message)
  * {{code}}@$list{{/code}} ⟹ The list if this variable exists, null otherwise
@@ -843,7 +843,7 @@
  === Static lookups ===
--There are a few data types which are basically enumerations: They only consist of a set of named values, e.g. the "class" data type, which is used for the component classes that exist in the game. For all these static enumeration classes there is a lookup value of the same name, from which you can get the named values as properties by their name. So for the type "class", there is a value "class" that can be used to access the classes.
++There are a few data types which are basically enumerations: They only consist of a set of named values, e.g. the ΓÇ£classΓÇ¥ data type, which is used for the component classes that exist in the game. For all these static enumeration classes there is a lookup value of the same name, from which you can get the named values as properties by their name. So for the type ΓÇ£classΓÇ¥, there is a value ΓÇ£classΓÇ¥ that can be used to access the classes.
  Here are a few enumeration classes and corresponding example lookup values:
@@ -901,11 +901,11 @@
  <code>typeof $value == datatype.faction</code>
--However, you should not compare the type to datatype.string because there are strings that have different data types. To check for a string you should use the datatype's property "'''isstring'''" instead. For example, to check if the variable $value is a string, use the following term:
++However, you should not compare the type to datatype.string because there are strings that have different data types. To check for a string you should use the datatype's property &quot;'''isstring'''&quot; instead. For example, to check if the variable $value is a string, use the following term:
  <code>(typeof $value).isstring</code>"{{/info}}
--{{info}}There is also the datatype "tag" with the lookup name "tag" - however, this is not an enumeration type. Looking up a value by name never fails, you actually create a tag value for a given name if it does not exist. For example, if you have a typo, like "tag.mision" instead of "tag.mission", there won't be an error because any name is valid for a tag, and the tag "mision" is created on its first use."{{/info}}
++{{info}}There is also the datatype ΓÇ£tagΓÇ¥ with the lookup name ΓÇ£tagΓÇ¥ - however, this is not an enumeration type. Looking up a value by name never fails, you actually create a tag value for a given name if it does not exist. For example, if you have a typo, like ΓÇ£tag.misionΓÇ¥ instead of ΓÇ£tag.missionΓÇ¥, there wonΓÇÖt be an error because any name is valid for a tag, and the tag ΓÇ£misionΓÇ¥ is created on its first use."{{/info}}
  \\
@@ -915,11 +915,11 @@
  === Player properties ===
--You can access many player-related game properties via the keyword "player":
++You can access many player-related game properties via the keyword ΓÇ£playerΓÇ¥:
--* player.**name**: The player's name
++* player.**name**: The playerΓÇÖs name
  * player.**age**: The passed in-game time since game start
--* player.**money**: The money in the player's account
++* player.**money**: The money in the playerΓÇÖs account
  * player.**ship**: The ship the player is currently on (not necessarily the player's ship), or null if the player is on a station\\
@@ -946,7 +946,7 @@
  * available
  * isclass.(...)
--These properties will not cause errors when used on "null" or on a destroyed object (which may still be accessible from scripts in some cases), and produce null or false as results, respectively. (The keyword "available" is used for trades, not for objects. Trades can also become invalid.) However, when using such a property on a different data type like a number, there will still be an error.
++These properties will not cause errors when used on ΓÇ£nullΓÇ¥ or on a destroyed object (which may still be accessible from scripts in some cases), and produce null or false as results, respectively. (The keyword ΓÇ£availableΓÇ¥ is used for trades, not for objects. Trades can also become invalid.) However, when using such a property on a different data type like a number, there will still be an error.
  (% id="categorybroken_macroanchormoney-and-time-formatting" %)=== Money and time formatting
@@ -1019,24 +1019,24 @@
  {{info}}scriptproperties.html has to load files from different folders, which modern browsers do not allow by default for security reasons. In order to open scriptproperties.html, the following is required:
--* Firefox: On the about:config page, the value of "security.fileuri.strict_origin_policy" has to be changed to "false".
++* Firefox: On the about:config page, the value of &quot;security.fileuri.strict_origin_policy&quot; has to be changed to &quot;false&quot;.
  * Chrome: The Chrome launcher has to be started with the command-line parameter --allow-file-access-from-files{{/info}}
--This provides you with a complete list of all supported "base keywords" and properties. To filter in this list, you can enter an expression in the text field:
++This provides you with a complete list of all supported ΓÇ£base keywordsΓÇ¥ and properties. To filter in this list, you can enter an expression in the text field:
  * Enter the beginning of a base keyword
--* Enter $ followed by the data type you are looking for (e.g. "$ship"), as if it were a variable
--* To see the properties of a base keyword or data type, enter a dot (".")
++* Enter $ followed by the data type you are looking for (e.g. ΓÇ£$shipΓÇ¥), as if it were a variable
++* To see the properties of a base keyword or data type, enter a dot (ΓÇ£.ΓÇ¥)
  * After the dot, you can enter a property name
--* You can also enter a dot (".") as first character to search globally for a property
++* You can also enter a dot (ΓÇ£.ΓÇ¥) as first character to search globally for a property
  \\
--{{info}}The documentation contains some data types that are no real script data types, but which are useful for documentation purposes. For example, ships and stations are both of datatype "component", but have different properties based on their component class.{{/info}}
++{{info}}The documentation contains some data types that are no real script data types, but which are useful for documentation purposes. For example, ships and stations are both of datatype ΓÇ£componentΓÇ¥, but have different properties based on their component class.{{/info}}
@@ -1046,7 +1046,7 @@
  = MD refreshing and patching =
--When a saved game is loaded, the saved MD state is restored, but also all MD files are reloaded and changes in them are applied to the MD state. This is called "refresh". It is also possible to refresh the MD at run-time using the command "refreshmd" on the in-game command line. This is a convenient way to update MD scripts while the game is already running.
++When a saved game is loaded, the saved MD state is restored, but also all MD files are reloaded and changes in them are applied to the MD state. This is called ΓÇ£refreshΓÇ¥. It is also possible to refresh the MD at run-time using the command ΓÇ£refreshmdΓÇ¥ on the in-game command line. This is a convenient way to update MD scripts while the game is already running.
  \\
@@ -1089,13 +1089,13 @@
  Cues can have **<patch>** elements with actions that will be performed when an old savegame is loaded. To control which savegames should be affected, you can add a //**version **//attribute to the <cue> node and a //**sinceversion**// attribute in the patch. When a cue is loaded from a savegame that has an older version than //sinceversion//, the <patch> actions will be performed immediately after loading.
--{{code language="xml"}}<cue [...] version="42"> <conditions> [...] </conditions> <actions> [...] </actions> <patch sinceversion="42">    [patch actions] </patch></cue>{{/code}}
++{{code}}&lt;cue┬á[...] version=&quot;42&quot;&gt; &lt;conditions&gt; [...] &lt;/conditions&gt; &lt;actions&gt; [...] &lt;/actions&gt; &lt;patch┬ásinceversion=&quot;42&quot;&gt;┬á┬á┬á [patch actions] &lt;/patch&gt;&lt;/cue&gt;{{/code}}
--The patch actions are only performed if the cue is in a certain state, "complete" by default. Use the //**state**// attribute to change this requirement. For more information, see the XML schema documentation of the <patch> element.
++The patch actions are only performed if the cue is in a certain state, ΓÇ£completeΓÇ¥ by default. Use the //**state**// attribute to change this requirement. For more information, see the XML schema documentation of the <patch> element.
  A sequence of multiple <patch> elements is possible. They will be performed in order of appearance, checking the //sinceversion// and //state// attributes in each case. Patches are also applied to all users of a library and to instances.
--{{info}}The <patch> elements will be ignored when refreshing the MD at run-time. They only affect loaded savegames."{{/info}}
++{{info}}The &lt;patch&gt; elements will be ignored when refreshing the MD at run-time. They only affect loaded savegames."{{/info}}
@@ -1115,11 +1115,11 @@
  There are many conditions and conditional actions that require a value comparison, for example the condition <check_value>:
--{{code language="xml"}}<check_value value="$ware == ware.silicon and $amount != 0"/>{{/code}}
++{{code}}&lt;check_value┬ávalue=&quot;$ware == ware.silicon and $amount != 0&quot;/&gt;{{/code}}
  In the value attribute you specify a boolean expression, and if it is true (that is, not equal to zero), the condition is met. This is a special case: This condition and all other nodes that support a value comparison allows you to specify an upper limit, a lower limit, a number range, or a list of allowed values. Examples:
--{{code language="xml"}}<check_value value="FooCue.state" exact="cuestate.complete"/><check_value value="$foo.count" min="5"/><check_value value="$foo" max="player.age + 1min"/><check_value value="player.money" min="300Cr" max="600Cr"/><check_value value="$method" list="[killmethod.hitbymissile, killmethod.collected]"/><check_value value="$attention" min="attention.visible"/>{{/code}}
++{{code}}&lt;check_value┬ávalue=&quot;FooCue.state&quot;┬áexact=&quot;cuestate.complete&quot;/&gt;&lt;check_value┬ávalue=&quot;$foo.count&quot;┬ámin=&quot;5&quot;/&gt;&lt;check_value┬ávalue=&quot;$foo&quot;┬ámax=&quot;player.age + 1min&quot;/&gt;&lt;check_value┬ávalue=&quot;player.money&quot;┬ámin=&quot;300Cr&quot; max=&quot;600Cr&quot;/&gt;&lt;check_value┬ávalue=&quot;$method&quot;┬álist=&quot;[killmethod.hitbymissile, killmethod.collected]&quot;/&gt;&lt;check_value┬ávalue=&quot;$attention&quot;┬ámin=&quot;attention.visible&quot;/&gt;{{/code}}
  {{info}}Values of most enumeration types cannot be compared via ''min'' or ''max'' (also not via lt, gt, etc.). The only data types that can be used with ''min'' and ''max'' are numbers and the enumeration types ''level'' and ''attention'' (see Boolean operators). The ''exact'' attribute can be used with any type, and is equivalent to using the == operator."{{/info}}
@@ -1127,26 +1127,29 @@
  \\
++(% id="categorybroken_macroanchorrandom-ranges" %)
++
  == Random ranges ==
  If an action requires a value, e.g. when you set a variable to a value, you can have some randomisation. To specify an exact value, e.g. in <set_value>, you can write this:
--{{code language="xml"}}<set_value name="$race" exact="race.teladi"/>{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$race&quot;┬áexact=&quot;race.teladi&quot;/&gt;{{/code}}
  To select a random element from a list, this syntax can be used:
--{{code language="xml"}}<set_value name="$prime" list="[2, 3, 5, 7, 11]"/>{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$prime&quot;┬álist=&quot;[2, 3, 5, 7, 11]&quot;/&gt;{{/code}}
  To get a random number within a given range, you can use min/max:
--{{code language="xml"}}<set_value name="$foo" min="-20" max="20"/><set_value name="$timeout" max="20s"/>{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$foo&quot;┬ámin=&quot;-20&quot;┬ámax=&quot;20&quot;/&gt;&lt;set_value┬áname=&quot;$timeout&quot;┬ámax=&quot;20s&quot;/&gt;{{/code}}
  min and max have to be compatible number types. Enumeration types are not allowed, not even level and attention. The min attribute is optional and defaults to 0 (of the number type used in max).
--You can select one of 5 different probability distribution profiles for the random range, "flat" being the default (all values in the range are equally likely). If you select another profile, e.g. "increasing" to make higher numbers more likely, you also have to specify a scale value (integer) that is greater or equal to 2. Higher scale values result in higher peaks in the distribution profiles (probable values become even more probable).
++You can select one of 5 different probability distribution profiles for the random range, ΓÇ£flatΓÇ¥ being the default (all values in the range are equally likely). If you select another profile, e.g. ΓÇ£increasingΓÇ¥ to make higher numbers more likely, you also have to specify a scale value (integer) that is greater or equal to 2. Higher scale values result in higher peaks in the distribution profiles (probable values become even more probable).
--{{code language="xml"}}<set_value name="$foo" min="-20" max="20" profile="profile.increasing" scale="4"/>{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$foo&quot;┬ámin=&quot;-20&quot;┬ámax=&quot;20&quot; profile=&quot;profile.increasing&quot; scale=&quot;4&quot;/&gt;{{/code}}
++(% style="color: rgb(0,0,255);text-decoration: none;" %)
  \\(% id="variables-and-namespaces" %)
  = Variables and namespaces =
@@ -1153,43 +1153,44 @@
  As you have seen above, you can easily access variables by writing their name (including $ prefix) in an expression. Namespaces define in which cue the variables are actually stored (and from which cue they are read).
--
++(% style="color: rgb(0,0,255);text-decoration: none;" %)
  \\\\\\(% id="categorybroken_macroanchorcreating-and-removing-variables" %)
  == Creating and removing variables ==
--You can create variables with certain actions and conditions, such as the <set_value> action:
++{{{You can create variables with certain actions and conditions, such as the &lt;set_value&gt; action:}}}
--{{code language="xml"}}<set_value name="$foo" exact="$bar + 1" />{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$foo&quot;┬áexact=&quot;$bar + 1&quot; /&gt;{{/code}}
--<set_value> also exists as a "condition", which can be useful if you want to pass information about the conditions to the actions, that would otherwise be lost - like in a complex <check_any> event condition, where you want to create a variable only if you are in a certain check branch. (Other pseudo-conditions are <remove_value> and <debug_text>.)
++<set_value> also exists as a ΓÇ£conditionΓÇ¥, which can be useful if you want to pass information about the conditions to the actions, that would otherwise be lost - like in a complex <check_any> event condition, where you want to create a variable only if you are in a certain check branch. (Other pseudo-conditions are <remove_value> and <debug_text>.)
--The default operation of <set_value> is "**set**", but there are more: "**add**", "**subtract**", and "**insert**". //add// and //subtract// change the value of an existing variable, which is created as 0 if it didn't exist before. If neither //min//, //max// nor //exact// attribute is provided, an exact value of 1 is assumed.
++The default operation of <set_value> is ΓÇ£**set**ΓÇ¥, but there are more: ΓÇ£**add**ΓÇ¥, ΓÇ£**subtract**ΓÇ¥, and ΓÇ£**insert**ΓÇ¥. //add// and //subtract// change the value of an existing variable, which is created as 0 if it didnΓÇÖt exist before. If neither //min//, //max// nor //exact// attribute is provided, an exact value of 1 is assumed.
--{{code language="xml"}}<set_value name="$foo" operation="add" />{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$foo&quot;┬áoperation=&quot;add&quot; /&gt;{{/code}}
  The trick is that <set_value> not only works on variables, but also on list elements and table keys:
--{{code language="xml"}}<set_value name="$list.{1}" exact="42" /><set_value name="$table.$foo" exact="42" />{{/code}}\\
++{{code}}&lt;set_value┬áname=&quot;$list.{1}&quot;┬áexact=&quot;42&quot; /&gt;&lt;set_value┬áname=&quot;$table.$foo&quot;┬áexact=&quot;42&quot; /&gt;{{/code}}\\
  The operation //insert// is special, and it only works on lists. It inserts the value at the specified position (note that the position beyond the last element is also valid here):
--{{code language="xml"}}<set_value name="$list.{1}" exact="42" operation="insert" />{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$list.{1}&quot;┬áexact=&quot;42&quot;┬áoperation=&quot;insert&quot; /&gt;{{/code}}
  This shifts the positions of all following elements up by one. If min/max/exact are missing, the default value is null for insertions, not 1 like in other cases.
  Appending is easier than that. The following actions are equivalent:
--{{code language="xml"}}<set_value name="$list.{$list.count + 1}" exact="42" operation="insert" /><append_to_list name="$list" exact="42" />{{/code}}
++{{code}}&lt;set_value┬áname=&quot;$list.{$list.count + 1}&quot;┬áexact=&quot;42&quot;┬áoperation=&quot;insert&quot; /&gt;&lt;append_to_list┬áname=&quot;$list&quot;┬áexact=&quot;42&quot; /&gt;{{/code}}
  Inserting at a position below 1 or above $list.count + 1 is not possible.
  To remove variables or list/table entries, use <remove_value>:
--{{code language="xml"}}<remove_value name="$foo" /><remove_value name="$list.{1}" /><remove_value name="$table.$foo" />{{/code}}\\
++{{code}}&lt;remove_value┬áname=&quot;$foo&quot; /&gt;&lt;remove_value┬áname=&quot;$list.{1}&quot; /&gt;&lt;remove_value┬áname=&quot;$table.$foo&quot; /&gt;{{/code}}\\
  Removing an entry from a list shifts all following elements down by one. If you want to clear an entry without removing it from the list, just use <set_value> instead.
++(% style="color: rgb(0,0,255);text-decoration: none;" %)
  \\\\\\(% id="accessing-remote-variables" %)
  == Accessing remote variables ==
@@ -1196,37 +1196,40 @@
  You can also read and write variables in other cues by using the variable name as property key:
--{{code language="xml"}}<set_value name="OtherCue.$foo" min="0.0" max="1.0" /><set_value name="md.OtherScript.YetAnotherCue.$bar" exact="OtherCue.$foo" />{{/code}}
++{{code}}&lt;set_value┬áname=&quot;OtherCue.$foo&quot;┬ámin=&quot;0.0&quot;┬ámax=&quot;1.0&quot; /&gt;&lt;set_value┬áname=&quot;md.OtherScript.YetAnotherCue.$bar&quot;┬áexact=&quot;OtherCue.$foo&quot; /&gt;{{/code}}
  Instead of referencing a cue by name, you could also reference it via a keyword or another variable:
--{{code language="xml"}}<set_value name="static.$counter" operation="add" /><set_value name="parent.$foo" exact="42" /><set_value name="this.$bar" exact="parent" /><set_value name="$baz" exact="this.$bar.$foo" />{{/code}}
++{{code}}&lt;set_value┬áname=&quot;static.$counter&quot;┬áoperation=&quot;add&quot; /&gt;&lt;set_value┬áname=&quot;parent.$foo&quot;┬áexact=&quot;42&quot; /&gt;&lt;set_value┬áname=&quot;this.$bar&quot;┬áexact=&quot;parent&quot; /&gt;&lt;set_value┬áname=&quot;$baz&quot;┬áexact=&quot;this.$bar.$foo&quot; /&gt;{{/code}}
++(% style="color: rgb(0,0,255);text-decoration: none;" %)
  \\\\\\(% id="namespaces" %)
  == Namespaces ==
--In the examples above, a variable was written to and read from the "this" cue. This can be necessary: the expression "$foo" may be different from the expression "this.$foo". The reason for that are namespaces.
++In the examples above, a variable was written to and read from the ΓÇ£thisΓÇ¥ cue. This can be necessary: the expression ΓÇ£$fooΓÇ¥ may be different from the expression ΓÇ£this.$fooΓÇ¥. The reason for that are namespaces.
  Consider this case:
--{{code language="xml"}}<cue name="Root"> <actions>  <set_value name="$foo" /> </actions> <cues>  <cue name="SubCue"> [...]  </cue> </cues></cue>{{/code}}
++{{code}}&lt;cue┬áname=&quot;Root&quot;&gt; &lt;actions&gt;  &lt;set_value┬áname=&quot;$foo&quot; /&gt; &lt;/actions&gt; &lt;cues&gt;  &lt;cue┬áname=&quot;SubCue&quot;&gt; [...]  &lt;/cue&gt; &lt;/cues&gt;&lt;/cue&gt;{{/code}}
--When the root cue creates $foo, the variable is stored in the Root cue directly. But SubCue and its descendants will also need access to $foo. Of course they could write "parent.$foo" or "Root.$foo", but since it's very common to have a single location for most variables in the whole cue tree, the easy solution is to write just "$foo" - because variable names are looked up in the **namespace cue**, which is the root by default. Also newly created variables end up in the namespace, and not in "this" cue.
++When the root cue creates $foo, the variable is stored in the Root cue directly. But SubCue and its descendants will also need access to $foo. Of course they could write ΓÇ£parent.$fooΓÇ¥ or ΓÇ£Root.$fooΓÇ¥, but since itΓÇÖs very common to have a single location for most variables in the whole cue tree, the easy solution is to write just ΓÇ£$fooΓÇ¥ - because variable names are looked up in the **namespace cue**, which is the root by default. Also newly created variables end up in the namespace, and not in ΓÇ£thisΓÇ¥ cue.
--You can also use the keyword "**namespace**" in expressions to get the namespace cue.
++You can also use the keyword ΓÇ£**namespace**ΓÇ¥ in expressions to get the namespace cue.
  (% id="defining-a-cues-namespace" %)
--=== Defining a cue's namespace ===
++=== Defining a cueΓÇÖs namespace ===
  When writing a cue, you can specify what the namespace of the cue should be, by adding the //**namespace**// attribute. The following values are possible:
--* **this**: Use "this" cue as namespace, even for instances: $foo == this.$foo
--* **static**: Same as "this", but when instantiated, use the static cue: $foo == static.$foo
--* **default**: The namespace is inherited from the parent cue. The default for root cues and for libraries is the same as "static".
++* **this**: Use ΓÇ£thisΓÇ¥ cue as namespace, even for instances: $foo == this.$foo
++* **static**: Same as ΓÇ£thisΓÇ¥, but when instantiated, use the static cue: $foo == static.$foo
++* **default**: The namespace is inherited from the parent cue. The default for root cues and for libraries is the same as ΓÇ£staticΓÇ¥.
++(% style="color: rgb(0,0,255);text-decoration: none;" %)
--{{warning}}Although in general the expression "$foo == namespace.$foo" is true, there is one exception: When library parameters are evaluated in the referencing cue, variables are resolved using the parent's namespace. However, the referencing cue creates a new namespace, so the namespace keyword already points to the library, not to the parent's namespace. Example:
--<code language="xml"><cue name="LibRef" ref="Lib"> <param name="Param1" value="$foo" /> <!-- $foo from parent namespace --> <param name="Param2" value="namespace.$foo" /> <!-- LibRef.$foo (error) --></cue></code>{{/warning}}
++{{warning}}Although in general the expression ΓÇ£$foo == namespace.$fooΓÇ¥ is true, there is one exception: When library parameters are evaluated in the referencing cue, variables are resolved using the parentΓÇÖs namespace. However, the referencing cue creates a new namespace, so the namespace keyword already points to the library, not to the parentΓÇÖs namespace. Example:
++
++<code>&lt;cue┬áname=&quot;LibRef&quot;┬áref=&quot;Lib&quot;&gt; &lt;param┬áname=&quot;Param1&quot;┬ávalue=&quot;$foo&quot; /&gt; &lt;!-- $foo from parent namespace --&gt; &lt;param┬áname=&quot;Param2&quot;┬ávalue=&quot;namespace.$foo&quot; /&gt; &lt;!-- LibRef.$foo (error) --&gt;&lt;/cue&gt;</code>{{/warning}}

Changes for page Mission Director Guide

Summary

Details

Navigation

Applications