VarAction2Advanced - Revision history

Frosch: ottd always behaved like that; though only now it is official

2011-08-22T19:06:24Z

ottd always behaved like that; though only now it is official

← Older revision		Revision as of 19:06, 22 August 2011
Line 110:		Line 110:
	When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.		When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.

	The called action 2 should return a callback result. {{ottdp\|1.2\|2.6\|ttdprev=r2367}} If the chain ends in a regular action2, the returned result is 0xFFFF. For earlier versions of TTDPatch the variable 7E value was undefined in this case.		The called action 2 should return a callback result. {{ottdp\|0.6\|2.6\|ttdprev=r2367}} If the chain ends in a regular action2, the returned result is 0xFFFF. For earlier versions of TTDPatch the variable 7E value was undefined in this case.

	Because callback results are limited to 15 bits, to access the full 32 bit result you can read variable 1C instead (e.g. by and-ing the 7E result with 0 and then adding var. 1C).		Because callback results are limited to 15 bits, to access the full 32 bit result you can read variable 1C instead (e.g. by and-ing the 7E result with 0 and then adding var. 1C).

Michi cc: /* Using procedures */ typo

2011-08-22T10:07:15Z

Using procedures: typo

← Older revision		Revision as of 10:07, 22 August 2011
Line 110:		Line 110:
	When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.		When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.

	The called action 2 should return a callback result. {{ottdp\|1.2\|2.6\|ttdprev=~~2367~~}} If the chain ends in a regular action2, the returned result is 0xFFFF. For earlier versions of TTDPatch the variable 7E value was undefined in this case.		The called action 2 should return a callback result. {{ottdp\|1.2\|2.6\|ttdprev=r2367}} If the chain ends in a regular action2, the returned result is 0xFFFF. For earlier versions of TTDPatch the variable 7E value was undefined in this case.

	Because callback results are limited to 15 bits, to access the full 32 bit result you can read variable 1C instead (e.g. by and-ing the 7E result with 0 and then adding var. 1C).		Because callback results are limited to 15 bits, to access the full 32 bit result you can read variable 1C instead (e.g. by and-ing the 7E result with 0 and then adding var. 1C).

Planetmaker: /* Using procedures */ Return 0xFFFF if the 7E call ends in a regular action2.

2011-08-22T05:09:02Z

Using procedures: Return 0xFFFF if the 7E call ends in a regular action2.

← Older revision		Revision as of 05:09, 22 August 2011
Line 110:		Line 110:
	When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.		When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.

	The called action 2 ~~must~~ return a callback result. If the chain ends in a regular ~~action 2 instead of returning a callback result~~, the ~~variable~~ ~~7E value~~ is ~~undefined~~. ~~ Because~~ ~~callback~~ ~~results~~ ~~are limited to 15 bits, to~~ ~~access~~ the ~~full 32 bit result you can read~~ variable ~~1C instead (e.g. by anding the~~ 7E ~~result~~ ~~with~~ 0 ~~and~~ ~~then adding var.~~ ~~1C)~~.		The called action 2 should return a callback result. {{ottdp\|1.2\|2.6\|ttdprev=2367}} If the chain ends in a regular action2, the returned result is 0xFFFF. For earlier versions of TTDPatch the variable 7E value was undefined in this case.

			Because callback results are limited to 15 bits, to access the full 32 bit result you can read variable 1C instead (e.g. by and-ing the 7E result with 0 and then adding var. 1C).

	The feature of this called action 2 is ignored, and all variables accessed use the same feature as the calling VarAction2. It is however valid to use any type of VarAction2, e.g. types 81 and 82 and the various byte/word/dword sizes may be mixed. It is also valid to use nvar=00 to return the computed value as callback result, instead of specifying ranges, although this way the return value is still limited to 15 bits. When using a random action 2 in the called chain, random triggers are processed in the same way as in "normal" chains.		The feature of this called action 2 is ignored, and all variables accessed use the same feature as the calling VarAction2. It is however valid to use any type of VarAction2, e.g. types 81 and 82 and the various byte/word/dword sizes may be mixed. It is also valid to use nvar=00 to return the computed value as callback result, instead of specifying ranges, although this way the return value is still limited to 15 bits. When using a random action 2 in the called chain, random triggers are processed in the same way as in "normal" chains.

Frosch: typo

2011-07-25T20:28:24Z

typo

← Older revision		Revision as of 20:28, 25 July 2011
Line 114:		Line 114:
	The feature of this called action 2 is ignored, and all variables accessed use the same feature as the calling VarAction2. It is however valid to use any type of VarAction2, e.g. types 81 and 82 and the various byte/word/dword sizes may be mixed. It is also valid to use nvar=00 to return the computed value as callback result, instead of specifying ranges, although this way the return value is still limited to 15 bits. When using a random action 2 in the called chain, random triggers are processed in the same way as in "normal" chains.		The feature of this called action 2 is ignored, and all variables accessed use the same feature as the calling VarAction2. It is however valid to use any type of VarAction2, e.g. types 81 and 82 and the various byte/word/dword sizes may be mixed. It is also valid to use nvar=00 to return the computed value as callback result, instead of specifying ranges, although this way the return value is still limited to 15 bits. When using a random action 2 in the called chain, random triggers are processed in the same way as in "normal" chains.

	{{ottdp\|0.6\|2.5/2.6\|ttdprev=r846, will be in yet ~~unreleaed~~ 2.5 beta 10}}		{{ottdp\|0.6\|2.5/2.6\|ttdprev=r846, will be in yet unreleased 2.5 beta 10}}
	In TTDPatch 2.5 beta 9 and earlier and in TTDPatch 2.6 prior to r846, VarAction2s that attempt to perform multiple sequential (as opposed to nested) procedure calls will have undefined results.		In TTDPatch 2.5 beta 9 and earlier and in TTDPatch 2.6 prior to r846, VarAction2s that attempt to perform multiple sequential (as opposed to nested) procedure calls will have undefined results.

Frosch: version tags

2011-07-25T20:18:19Z

version tags

← Older revision		Revision as of 20:18, 25 July 2011
Line 107:		Line 107:

	=== Using procedures ===		=== Using procedures ===
			{{ottdp\|0.6\|2.5\|ttdprev=2.5 beta 7}}

	When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.		When the variable in a VarAction2 is 7E, the procedure given by the 60+x parameter is invoked. This means that the byte following the variable number (7E) specifies a variational or random action 2 ID to call, similarly to how a regular VarAction2 branches to other action 2 entries. However, instead of branching, it is a subroutine call, with the value calculated by the called entry being used as variable value.

	The called action 2 must return a callback result. If the chain ends in a regular action 2 instead of returning a callback result, the variable 7E value is undefined.  Because callback results are limited to 15 bits, to access the full 32 bit result you can read variable 1C instead (e.g. by anding the 7E result with 0 and then adding var. 1C).		The called action 2 must return a callback result. If the chain ends in a regular action 2 instead of returning a callback result, the variable 7E value is undefined.  Because callback results are limited to 15 bits, to access the full 32 bit result you can read variable 1C instead (e.g. by anding the 7E result with 0 and then adding var. 1C).

		⚫	The feature of this called action 2 is ignored, and all variables accessed use the same feature as the calling VarAction2. It is however valid to use any type of VarAction2, e.g. types 81 and 82 and the various byte/word/dword sizes may be mixed. It is also valid to use nvar=00 to return the computed value as callback result, instead of specifying ranges, although this way the return value is still limited to 15 bits. When using a random action 2 in the called chain, random triggers are processed in the same way as in "normal" chains.

			{{ottdp\|0.6\|2.5/2.6\|ttdprev=r846, will be in yet unreleaed 2.5 beta 10}}
	In TTDPatch 2.5 beta 9 and earlier and in TTDPatch 2.6 prior to r846, VarAction2s that attempt to perform multiple sequential (as opposed to nested) procedure calls will have undefined results.		In TTDPatch 2.5 beta 9 and earlier and in TTDPatch 2.6 prior to r846, VarAction2s that attempt to perform multiple sequential (as opposed to nested) procedure calls will have undefined results.

⚫	The feature of this called action 2 is ignored, and all variables accessed use the same feature as the calling VarAction2. It is however valid to use any type of VarAction2, e.g. types 81 and 82 and the various byte/word/dword sizes may be mixed. It is also valid to use nvar=00 to return the computed value as callback result, instead of specifying ranges, although this way the return value is still limited to 15 bits. When using a random action 2 in the called chain, random triggers are processed in the same way as in "normal" chains.

Frosch: version tags

2011-07-25T20:13:22Z

version tags

← Older revision		Revision as of 20:13, 25 July 2011
Line 96:		Line 96:

	=== Using types 81/82 (etc) simultaneously ===		=== Using types 81/82 (etc) simultaneously ===
			{{ottdp\|0.6\|2.5\|ttdprev=2.0.1 alpha 59}}

	Since TTDPatch 2.0.1 alpha 59, it is possible to access variables using both VarAction2 type 81 and 82 (and their W/D cousins) indirectly through the new variable 1C.		Since TTDPatch 2.0.1 alpha 59, it is possible to access variables using both VarAction2 type 81 and 82 (and their W/D cousins) indirectly through the new variable 1C.

	This variable stores the result of the current VarAction2 and makes it available to the next VarAction2 in the chain.  Therefore, to access, for instance when drawing a house, both house variables (type 81) and town variables (type 82), you would read the house variables in one var. action 2, type 81, and then chain to the next VarAction2, type 82.  There, you now have access to the house variable value stored in variable 1C as well as the town variables in the regular variables~~. Since TTDPatch 2.6 r1246, you may also store values in the 7D array, where they will persist for the life of the action 2 chain, unless overwritten~~.		This variable stores the result of the current VarAction2 and makes it available to the next VarAction2 in the chain.  Therefore, to access, for instance when drawing a house, both house variables (type 81) and town variables (type 82), you would read the house variables in one var. action 2, type 81, and then chain to the next VarAction2, type 82.  There, you now have access to the house variable value stored in variable 1C as well as the town variables in the regular variables.

	Note that to chain to the next VarAction2, you ''must not'' use nvar=0, because that returns the result value as a callback result.  Instead, you need to use nvar=1, and specify the chained VarAction2 in both the <set-id> and <default> positions.		Note that to chain to the next VarAction2, you ''must not'' use nvar=0, because that returns the result value as a callback result.  Instead, you need to use nvar=1, and specify the chained VarAction2 in both the <set-id> and <default> positions.

			{{ottdp\|0.6\|2.6\|ttdprev=r1246}}
			Since TTDPatch 2.6 r1246, you may also store values in the 7D array, where they will persist for the life of the action 2 chain, unless overwritten.

	=== Using procedures ===		=== Using procedures ===

Frosch: separate rows for each operator

2011-07-25T20:05:38Z

separate rows for each operator

← Older revision		Revision as of 20:05, 25 July 2011
Line 42:		Line 42:
	\|01\|\|\2-\|\|result = val1 - val2\|\|{{ottdp\|0.6\|2.5}}\|\|		\|01\|\|\2-\|\|result = val1 - val2\|\|{{ottdp\|0.6\|2.5}}\|\|
	\|-		\|-
	\|02\|\|\2<\|\|result = min(val1, val2)\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|02\|\|\2<\|\|result = min(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered signed
	\|-		\|-
	\|03\|\|\2>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|03\|\|\2>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
	\|-		\|-
	\|04~~,05~~\|\|\2u<~~, \2u>~~\|\|result = ~~max~~(val1, val2)\|\|{{ottdp\|0.6\|2.5}}~~\|\|Same as 02/03, but operands are considered unsigned~~		\|04\|\|\2u<\|\|result = min(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered unsigned
	\|-		\|-
	\|06\|\|\2/\|\|result = val1 / val2\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|05\|\|\2u>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
	\|-		\|-
	\|07\|\|\2%\|\|result = val1 ~~mod~~ val2\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|06\|\|\2/\|\|result = val1 / val2\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered signed
	\|-		\|-
	\|~~08,09~~\|\|\~~2u/, \2u~~%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}~~\|\|Same as 06/07, but operands are considered unsigned~~		\|07\|\|\2%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}
			\|-
			\|08\|\|\2u/\|\|result = val1 / val2\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered unsigned
			\|-
			\|09\|\|\2u%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}
	\|-		\|-
	\|0A\|\|\2\|\|result = val1 val2\|\|{{ottdp\|0.6\|2.5}}\|\|result will be truncated to B/W/D (that makes it the same for signed/unsigned operands)		\|0A\|\|\2\|\|result = val1 val2\|\|{{ottdp\|0.6\|2.5}}\|\|result will be truncated to B/W/D (that makes it the same for signed/unsigned operands)

Frosch: use real footnotes

2011-07-25T19:58:51Z

use real footnotes

← Older revision		Revision as of 19:58, 25 July 2011
Line 62:		Line 62:
	\|0D\|\|\2<nowiki>^</nowiki>\|\|result = val1 <nowiki>^</nowiki> val2\|\|{{ottdp\|0.6\|2.5}}\|\|bitwise XOR		\|0D\|\|\2<nowiki>^</nowiki>\|\|result = val1 <nowiki>^</nowiki> val2\|\|{{ottdp\|0.6\|2.5}}\|\|bitwise XOR
	\|-		\|-
	\|0E\|\|\2s or \2sto (a)\|\|var7D[val2] = val1, result = val1\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1246}}\|\|Store result. See [[Storages#Temporary storage\|Temporary storage]].		\|0E\|\|\2s or \2sto <ref name="renum1265">Supported since grfcodec and nforenum r1265 (1.0.0 and 3.4.4, respectively.)</ref>\|\|var7D[val2] = val1, result = val1\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1246}}\|\|Store result. See [[Storages#Temporary storage\|Temporary storage]].
	\|-		\|-
	\|0F\|\|\2r or \2rst ~~(a)~~\|\|result = val2\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1246}}\|\|		\|0F\|\|\2r or \2rst <ref name="renum1265"/>\|\|result = val2 <ref>Operator 0F is only useful when using variable 7B, or immediately after operators 0E or 10, to store the result of a calculation, and then discard that result and start fresh.</ref>\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1246}}\|\|
	\|-		\|-
	\|10\|\|\2psto ~~(c)~~\|\|var7C[val2] = val1, result = val1\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1315}}\|\|Store result into persistent storage. See [[Storages#Persistent storage\|Persistent storage]].		\|10\|\|\2psto <ref name="grfcodec100">Supported since grfcodec 1.0.0 and nforenum 4.0.0.</ref>\|\|var7C[val2] = val1, result = val1\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1315}}\|\|Store result into persistent storage. See [[Storages#Persistent storage\|Persistent storage]].
	\|-		\|-
	\|11\|\|\2ror or \2rot (b)\|\|result = val1 rotate right val2\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1651}}\|\|Always a 32-bit rotation.		\|11\|\|\2ror or \2rot <ref>Supported since grfcodec and nforenum r1655 (1.0.0 and 3.4.6, respectively.)</ref>\|\|result = val1 rotate right val2\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1651}}\|\|Always a 32-bit rotation.
	\|-		\|-
	\|12\|\|\2cmp ~~(c)~~\|\|see notes\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1698}}\|\|Result is 0 if val1<val2, 1 if val1=val2 and 2 if val1>val2. Both values are considered signed. (*)		\|12\|\|\2cmp <ref name="grfcodec100"/>\|\|see notes\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1698}}\|\|Result is 0 if val1<val2, 1 if val1=val2 and 2 if val1>val2. Both values are considered signed. <ref name="compare">Operations 12 and 13 should be preferred over operation 01 (subtraction) when only the relation of the two values is needed and the difference itself is irrelevant. This is because operation 01 can overflow and give the wrong sign if the difference is too big, but comparisons work correctly for all values.</ref>
	\|-		\|-
	\|13\|\|\2ucmp ~~(c)~~\|\|see notes\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1698}}\|\|The same as 12, but operands are considered unsigned. ~~(*)~~		\|13\|\|\2ucmp <ref name="grfcodec100"/>\|\|see notes\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1698}}\|\|The same as 12, but operands are considered unsigned. <ref name="compare"/>
	\|-		\|-
	\|14\|\|\2<< ~~(c)~~\|\|result = val1 << val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift left; val2 should be in the range 0 to 31.		\|14\|\|\2<< <ref name="grfcodec100"/>\|\|result = val1 << val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift left; val2 should be in the range 0 to 31.
	\|-		\|-
	\|15\|\|\2u>> ~~(c)~~\|\|result = val1 >> val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift right (unsigned); val2 should be in the range 0 to 31.		\|15\|\|\2u>> <ref name="grfcodec100"/>\|\|result = val1 >> val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift right (unsigned); val2 should be in the range 0 to 31.
	\|-		\|-
	\|16\|\|\2>> ~~(c)~~\|\|result = val1 >> val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift right (signed); val2 should be in the range 0 to 31.		\|16\|\|\2>> <ref name="grfcodec100"/>\|\|result = val1 >> val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift right (signed); val2 should be in the range 0 to 31.
	\|}		\|}

	where val1 is the value resulting from the current variable/varadjust pair (or the result of the previous calculations if this isn't the first pair) and val2 is the value resulting from the following variable/varadjust pair. By setting bit 5 of shift-num repeatedly, you can combine several variables together before making your decision.		where val1 is the value resulting from the current variable/varadjust pair (or the result of the previous calculations if this isn't the first pair) and val2 is the value resulting from the following variable/varadjust pair. By setting bit 5 of shift-num repeatedly, you can combine several variables together before making your decision.

			<references/>
	(a) Supported since grfcodec and nforenum r1265 (1.0.0 and 3.4.4, respectively.)

	(b) Supported since grfcodec and nforenum r1655 (1.0.0 and 3.4.6, respectively.)

	(c) Supported since grfcodec 1.0.0 and nforenum 4.0.0.

	<nowiki>*</nowiki> Operations 12 and 13 should be preferred over operation 01 (subtraction) when only the relation of the two values is needed and the difference itself is irrelevant. This is because operation 01 can overflow and give the wrong sign if the difference is too big, but comparisons work correctly for all values.

	Note that a bitwise NOT can be done by XORing with variable 1A. Similarly, you can specify literal values (i.e. plain numbers instead of variables), by using variable 1A and an and-mask of the value you want. For example, to specify a literal 26, use variable=1A, shift-num=00 (or the higher bits set if you need further calculations), and and-mask=26. This works with B, W or D sized literals if you use the right and-mask size for the given type of action 2. The appropriate \b, \w, or \d escape sequence can be useful for specifying literals. See [[GRFActionsDetailed#Byte order\|the discussion of escape sequences]] for further information.		Note that a bitwise NOT can be done by XORing with variable 1A. Similarly, you can specify literal values (i.e. plain numbers instead of variables), by using variable 1A and an and-mask of the value you want. For example, to specify a literal 26, use variable=1A, shift-num=00 (or the higher bits set if you need further calculations), and and-mask=26. This works with B, W or D sized literals if you use the right and-mask size for the given type of action 2. The appropriate \b, \w, or \d escape sequence can be useful for specifying literals. See [[GRFActionsDetailed#Byte order\|the discussion of escape sequences]] for further information.

	Operator 0F is only useful when using variable 7B, or immediately after operators 0E or 10, to store the result of a calculation, and then discard that result and start fresh.

	=== Using types 81/82 (etc) simultaneously ===		=== Using types 81/82 (etc) simultaneously ===

Frosch: version tags

2011-07-25T19:50:08Z

version tags

Pm-bot: Bot: Automated text replacement (-variational action 2 +VarAction2)

2011-06-19T16:33:41Z

Bot: Automated text replacement (-variational action 2 +VarAction2)

← Older revision		Revision as of 16:33, 19 June 2011
Line 3:		Line 3:
	A regular action 2 can access one variable and perform limited modifications on it (shift, and, add, divide/modulo) instead of a simple variable access. Using an advanced action 2, it is possible to do a nearly unlimited number of many different operations on several variables.		A regular action 2 can access one variable and perform limited modifications on it (shift, and, add, divide/modulo) instead of a simple variable access. Using an advanced action 2, it is possible to do a nearly unlimited number of many different operations on several variables.

	In addition, using procedure calls (with variable 7E), it is possible to reuse ~~variational action 2~~ blocks in several places on the NFO code.		In addition, using procedure calls (with variable 7E), it is possible to reuse VarAction2 blocks in several places on the NFO code.

	== Format ==		== Format ==

	An advanced ~~variational action 2~~ looks as follows:		An advanced VarAction2 looks as follows:

	<Sprite-number> * <Length> 02 <feature> <set-id> <type> <variable> <varadjust> '''[<operator> <variable> <varadjust>]'''... <nvar> (<set-id> <low-range> <high-range>){n} <default>		<Sprite-number> * <Length> 02 <feature> <set-id> <type> <variable> <varadjust> '''[<operator> <variable> <varadjust>]'''... <nvar> (<set-id> <low-range> <high-range>){n} <default>

← Older revision		Revision as of 20:05, 25 July 2011
Line 42:		Line 42:
	\|01\|\|\2-\|\|result = val1 - val2\|\|{{ottdp\|0.6\|2.5}}\|\|		\|01\|\|\2-\|\|result = val1 - val2\|\|{{ottdp\|0.6\|2.5}}\|\|
	\|-		\|-
	\|02\|\|\2<\|\|result = min(val1, val2)\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|02\|\|\2<\|\|result = min(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered signed
	\|-		\|-
	\|03\|\|\2>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|03\|\|\2>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
	\|-		\|-
	\|04~~,05~~\|\|\2u<~~, \2u>~~\|\|result = ~~max~~(val1, val2)\|\|{{ottdp\|0.6\|2.5}}~~\|\|Same as 02/03, but operands are considered unsigned~~		\|04\|\|\2u<\|\|result = min(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered unsigned
	\|-		\|-
	\|06\|\|\2/\|\|result = val1 / val2\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|05\|\|\2u>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}
	\|-		\|-
	\|07\|\|\2%\|\|result = val1 ~~mod~~ val2\|\|{{ottdp\|0.6\|2.5}}~~\|\|val1 and val2 are both considered signed~~		\|06\|\|\2/\|\|result = val1 / val2\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered signed
	\|-		\|-
	\|~~08,09~~\|\|\~~2u/, \2u~~%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}~~\|\|Same as 06/07, but operands are considered unsigned~~		\|07\|\|\2%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}
			\|-
			\|08\|\|\2u/\|\|result = val1 / val2\|\|{{ottdp\|0.6\|2.5}}
			\|rowspan=2\|val1 and val2 are both considered unsigned
			\|-
			\|09\|\|\2u%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}
	\|-		\|-
	\|0A\|\|\2\|\|result = val1 val2\|\|{{ottdp\|0.6\|2.5}}\|\|result will be truncated to B/W/D (that makes it the same for signed/unsigned operands)		\|0A\|\|\2\|\|result = val1 val2\|\|{{ottdp\|0.6\|2.5}}\|\|result will be truncated to B/W/D (that makes it the same for signed/unsigned operands)

← Older revision		Revision as of 19:50, 25 July 2011
Line 36:		Line 36:

	{\|		{\|
	!Value!!Escape!!Effect!!Notes		!Value!!Escape!!Effect!!Version!!Notes
	\|-		\|-
	\|00\|\|\2+\|\|result = val1 + val2\|\|		\|00\|\|\2+\|\|result = val1 + val2\|\|{{ottdp\|0.6\|2.5}}\|\|
	\|-		\|-
	\|01\|\|\2-\|\|result = val1 - val2\|\|		\|01\|\|\2-\|\|result = val1 - val2\|\|{{ottdp\|0.6\|2.5}}\|\|
	\|-		\|-
	\|02\|\|\2<\|\|result = min(val1, val2)\|\|val1 and val2 are both considered signed		\|02\|\|\2<\|\|result = min(val1, val2)\|\|{{ottdp\|0.6\|2.5}}\|\|val1 and val2 are both considered signed
	\|-		\|-
	\|03\|\|\2>\|\|result = max(val1, val2)\|\|val1 and val2 are both considered signed		\|03\|\|\2>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}\|\|val1 and val2 are both considered signed
	\|-		\|-
	\|04,05\|\|\2u<, \2u>\|\|result = max(val1, val2)\|\|Same as 02/03, but operands are considered unsigned		\|04,05\|\|\2u<, \2u>\|\|result = max(val1, val2)\|\|{{ottdp\|0.6\|2.5}}\|\|Same as 02/03, but operands are considered unsigned
	\|-		\|-
	\|06\|\|\2/\|\|result = val1 / val2\|\|val1 and val2 are both considered signed		\|06\|\|\2/\|\|result = val1 / val2\|\|{{ottdp\|0.6\|2.5}}\|\|val1 and val2 are both considered signed
	\|-		\|-
	\|07\|\|\2%\|\|result = val1 mod val2\|\|val1 and val2 are both considered signed		\|07\|\|\2%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}\|\|val1 and val2 are both considered signed
	\|-		\|-
	\|08,09\|\|\2u/, \2u%\|\|result = val1 mod val2\|\|Same as 06/07, but operands are considered unsigned		\|08,09\|\|\2u/, \2u%\|\|result = val1 mod val2\|\|{{ottdp\|0.6\|2.5}}\|\|Same as 06/07, but operands are considered unsigned
	\|-		\|-
	\|0A\|\|\2\|\|result = val1 val2\|\|result will be truncated to B/W/D (that makes it the same for signed/unsigned operands)		\|0A\|\|\2\|\|result = val1 val2\|\|{{ottdp\|0.6\|2.5}}\|\|result will be truncated to B/W/D (that makes it the same for signed/unsigned operands)
	\|-		\|-
	\|0B\|\|\2&\|\|result = val1 & val2\|\|bitwise AND		\|0B\|\|\2&\|\|result = val1 & val2\|\|{{ottdp\|0.6\|2.5}}\|\|bitwise AND
	\|-		\|-
	\|0C\|\|\2<nowiki>\|</nowiki>\|\|result = val1 <nowiki>\|</nowiki> val2\|\|bitwise OR		\|0C\|\|\2<nowiki>\|</nowiki>\|\|result = val1 <nowiki>\|</nowiki> val2\|\|{{ottdp\|0.6\|2.5}}\|\|bitwise OR
	\|-		\|-
	\|0D\|\|\2<nowiki>^</nowiki>\|\|result = val1 <nowiki>^</nowiki> val2\|\|bitwise XOR		\|0D\|\|\2<nowiki>^</nowiki>\|\|result = val1 <nowiki>^</nowiki> val2\|\|{{ottdp\|0.6\|2.5}}\|\|bitwise XOR
	\|-		\|-
	\|0E\|\|\2s or \2sto (a)\|\|var7D[val2] = val1, result = val1\|\|~~Store result, available since TTDPatch~~ 2.6 ~~r1246~~. See [[Storages#Temporary storage\|Temporary storage]].		\|0E\|\|\2s or \2sto (a)\|\|var7D[val2] = val1, result = val1\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1246}}\|\|Store result. See [[Storages#Temporary storage\|Temporary storage]].
	\|-		\|-
	\|0F\|\|\2r or \2rst (a)\|\|result = val2\|\|~~Available since TTDPatch~~ 2.6 r1246		\|0F\|\|\2r or \2rst (a)\|\|result = val2\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1246}}\|\|
	\|-		\|-
	\|10\|\|\2psto (c)\|\|var7C[val2] = val1, result = val1\|\|Store result into persistent storage~~, available since TTDPatch 2.6 r1315~~. See [[Storages#Persistent storage\|Persistent storage]].		\|10\|\|\2psto (c)\|\|var7C[val2] = val1, result = val1\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1315}}\|\|Store result into persistent storage. See [[Storages#Persistent storage\|Persistent storage]].
	\|-		\|-
	\|11\|\|\2ror or \2rot (b)\|\|result = val1 rotate right val2\|\|Always a 32-bit rotation. ~~Available since TTDPatch 2.6 r1651~~		\|11\|\|\2ror or \2rot (b)\|\|result = val1 rotate right val2\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1651}}\|\|Always a 32-bit rotation.
	\|-		\|-
	\|12\|\|\2cmp (c)\|\|see notes\|\|Result is 0 if val1<val2, 1 if val1=val2 and 2 if val1>val2. Both values are considered signed. ~~Available since TTDPatch 2.6 r1698~~ (*)		\|12\|\|\2cmp (c)\|\|see notes\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1698}}\|\|Result is 0 if val1<val2, 1 if val1=val2 and 2 if val1>val2. Both values are considered signed. (*)
	\|-		\|-
	\|13\|\|\2ucmp (c)\|\|see notes\|\|The same as 12, but operands are considered unsigned. ~~Available since TTDPatch 2.6 r1698~~ (*)		\|13\|\|\2ucmp (c)\|\|see notes\|\|{{ottdp\|0.6\|2.6\|ttdprev=r1698}}\|\|The same as 12, but operands are considered unsigned. (*)
	\|-		\|-
	\|14\|\|\2<< (c)\|\|result = val1 << val2\|\|shift left; val2 should be in the range 0 to 31~~. Available since OpenTTD r20332 and TTDPatch r2335~~.		\|14\|\|\2<< (c)\|\|result = val1 << val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift left; val2 should be in the range 0 to 31.
	\|-		\|-
	\|15\|\|\2u>> (c)\|\|result = val1 >> val2\|\|shift right (unsigned); val2 should be in the range 0 to 31~~. Available since OpenTTD r20332 and TTDPatch r2335~~.		\|15\|\|\2u>> (c)\|\|result = val1 >> val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift right (unsigned); val2 should be in the range 0 to 31.
	\|-		\|-
	\|16\|\|\2>> (c)\|\|result = val1 >> val2\|\|shift right (signed); val2 should be in the range 0 to 31~~. Available since OpenTTD r20332 and TTDPatch r2335~~.		\|16\|\|\2>> (c)\|\|result = val1 >> val2\|\|{{ottdp\|1.1\|2.6\|ottdrev=r20332\|ttdprev=r2335}}\|\|shift right (signed); val2 should be in the range 0 to 31.
	\|}		\|}