Arrays:修订间差异

本页面所适用的版本可能已经过时,最后更新于1.10
(merge from offical wiki)
 
(文本替换 - 替换“[[Category:”为“[[分类:”)
 
(未显示3个用户的14个中间版本)
第1行: 第1行:
{{version|1.9}}
{{version|1.10}}
数组是《钢铁雄心IV》中用以存储变量的方式,变量既可以是{{ruby|'''数字形式'''|numerical data}}的,也可以是{{ruby|'''作用域'''|scope data}}形式的。


Arrays in general are containers that store elements (data). In Hearts of Iron IV it is possible to store numerical data and scope data within arrays.
数组在{{ruby|'''指令'''|effects}}中发挥作用,并且{{ruby|'''触发器'''|trigger}}能够从中读取数据。指令既可以使数组迭代入其他指令,也能使其数据在自身内进行迭代。


Arrays are used via effects and can be checked with triggers. There are special effects that allow you to iterate through an array to then apply other effects to or with the data within.
以下,使用<>括起的内容为'''数据类型''',等号左侧的标识符为'''参数名称'''。
== 指令(Effects)==
{{SVersion|1.10}}


== Effects ==
=== 添加到数组(add_to_array)  ===
{{SVersion|1.9}}
{{SVersion|1.10}}
 
=== add_to_array ===
{{SVersion|1.9}}


<pre>add_to_array = {
<pre>add_to_array = {
第17行: 第17行:
}
}
</pre>
</pre>
一旦将元素添加到数组中,就会创建一个数组。


An array is created once an element has been added to it.
array 是数组的名称,也是指令和触发器调用它的依据。


The name of the array is what you use to refer to the array in other effects and triggers.
value 是指要加入数组的数据内容,它既可以是数字形式的(如1 或 var:my_num),也可以是作用域形式的(如GER 或 var:my_scope)。这些都是选填内容,如果不填,则会将当前作用域填入此处。


The value is the data you are adding to the array. It can be a number (i.e. 1 or var:my_num) or a scope (i.e. GER or var:my_scope). This is optional, if not included the current scope is added as the value.
index 指数据内容应当被插入数组的哪个位置。{{ruby|'''缺省'''|default data}}(现普遍称'''默认''')情况下,value会接续在数组最后。其他情况下,原有的数据会自动向后移位以适应插入。


The index refers the where the value should be inserted into the array. By default data is added to the end of the array, otherwise the data is shifted to accommodate the new value.
这部分的简便写法是:<code>add_to_array = { <name> = <value> }</code>


A short form can be used: <code>add_to_array = { <name> = <value> }</code>
=== 从数组中移除(remove_from_array) ===
 
{{SVersion|1.10}}
=== remove_from_array ===
{{SVersion|1.9}}


<pre>remove_from_array = {
<pre>remove_from_array = {
   array = <name>
array = <name>
   value = <value>
value = <value>
   index = <index>
index = <index>
}
}
</pre>
</pre>
array 是将被移除数据的数组名称。


The name of the array is the array you want to remove the data from.
value 是想要移除的数据内容。


The value is the value you want to remove from the array (if present).
index 指移除操作所选择的'''开始'''位置。


The index is the index of the value you want to remove from the array (if present).
如果value和index都未定义,那么array只有最后一个元素会被移除。


If neither the value or index attributes are defined, the last element will be deleted.
这部分的简便写法是:<code>remove_from_array = { <name> = <value> }</code>


A short form can be used: <code>remove_from_array = { <name> = <value> }</code>
=== 清空数组(clear_array) ===
 
{{SVersion|1.10}}
=== clear_array ===
{{SVersion|1.9}}


<pre>clear_array = <name></pre>
<pre>clear_array = <name></pre>


Clears all data from the specified array.
清空指定数组。


=== resize_array ===
=== 重置数组规模(resize_array) ===
{{SVersion|1.9}}
{{SVersion|1.10}}


<pre>resize_array = {
<pre>resize_array = {
   array = <name>
array = <name>
   value = <value>
value = <value>
   size = <int>
size = <int>
}
}
</pre>
</pre>
重置特定数组array的规模(size)。


Resizes the specified array.
如果扩大现有数组的规模,多出来的新元素将被置为value;如果缩小现有数组的规模,则自index=size开始的元素将被丢弃。


The value attribute sets any empty elements to the specified value if expanding the array. Defaults to 0 if not specified.
这部分的简便写法是: <code>resize_array = { <name> = <size> }</code>


The size attribute specifies the new size of the array, removing elements if shrinking the array, or adding new elements with the specified value if expanding it.
===while循环指令(while_loop_effect)===
{{SVersion|1.10}}


A short form can be used: <code>resize_array = { <name> = <size> }</code>
<pre>
 
while_loop_effect = {
=== while_loop_effect ===
break = <string>
{{SVersion|1.9}}
limit = { <triggers> }
 
<pre>while_loop_effect = {
<effects>
   break = <string>
   limit = { <triggers> }
  
   <effects>
}
}
</pre>
</pre>
对指定数组进行有条件的循环操作。只要limit为真,就重复执行指令组(用花括号括起的指令集合)。


Runs the effect as long as a trigger is true.
break接受一个{{ruby|'''临时变量'''|temp variable}},当传递给break的变量取值为'''非0'''时,迭代将结束。缺省情况下,break接受的变量名为 <code>break</code>。break无法在本指令之外被访问。


The break attribute specifies a temp variable that can be set to non-0 to break the loop, ending iteration. By default this is <code>break</code>.
本指令接受指令组作为其参数,以指定对数组元素进行的操作。


Effects can be used within the loop to perform operations with the data within an array.
该指令会隐性地将当前数组array作为参数。


=== for_each_loop ===
===for each循环指令(for_each_loop)===
{{SVersion|1.9}}
{{SVersion|1.10}}


<pre>for_each_loop = {
<pre>
   array = <name>
for_each_loop = {
   value = <string>
array = <name>
   index = <string>
value = <string>
   break = <string>
index = <string>
  
break = <string>
   <effects>
<effects>
}
}
</pre>
</pre>
对指定数组中的每个元素调用指令组。


Runs a loop for each element of the specified array.
value指定了一个临时变量,指向迭代过程中的当前元素,缺省值为<code>v</code>。


The value attribute specifies a temp variable that stores the current value whilst iterating over the loop. By default this is <code>v</code>.
index指定了一个临时变量,指向迭代过程中的当前位置,缺省值为<code>i</code>


The index attribute specifies a temp variable that stores the current index whilst iterating over the loop. By default this is <code>i</code>.
break后应分配一个'''非零'''临时变量以结束迭代,缺省值为<code>break</code>


The break attribute specifies a temp variable that can be set to non-0 to break the loop, ending iteration. By default this is <code>break</code>.
在此循环中可以写入指令执行某些操作,并隐性地以当前数组为参数


Effects can be used within the loop to perform operations with the data within an array
===for each作用域循环指令(for_each_scope_loop)===
{{SVersion|1.10}}


=== for_each_scope_loop ===
<pre>
{{SVersion|1.9}}
for_each_scope_loop = {
 
array = <name>
<pre>for_each_scope_loop = {
break = <string>
   array = <name>
   break = <string>
<effects>
  
   <effects>
}
}
</pre>
</pre>
对指定数组中的每个元素调用指令组,并且在每次调用时将当前作用域更改为当前元素。


Runs a loop for each element of the specified array and changes the current scope to the current element in each iteration.
break后应分配一个'''非零'''临时变量以结束迭代,缺省值为<code>break</code>。


The break attribute specifies a temp variable that can be set to non-0 to break the loop, ending iteration. By default this is <code>break</code>.
在此循环中可以写入指令执行某些操作,并隐性地以当前数组为参数


Effects can be used within the loop to perform operations with the data within an array
===随机作用域指令(random_scope_in_array) ===
{{SVersion|1.10}}


=== random_scope_in_array ===
<pre>
{{SVersion|1.9}}
random_scope_in_array = {
 
array = <name>
<pre>random_scope_in_array = {
break = <string>
   array = <name>
limit = { <triggers> }
   break = <string>
   limit = { <triggers> }
<effects>
  
   <effects>
}
}
</pre>
</pre>
对特定的数组中的每一变量进行循环操作,并在每次迭代时将当前作用域改为随机作用域(当前数组内的一个随机的、不同于当前作用域的变量)。


Runs a loop for each element of the specified array and changes the current scope to a random scope (out of the scopes within the array) that meet the triggers specified.
break后应分配一个'''非零'''临时变量以结束迭代,缺省值为<code>break</code>。


The break attribute specifies a temp variable that can be set to non-0 to break the loop, ending iteration. By default this is <code>break</code>.
在此循环中可以写入指令执行某些操作,所用的数据内容应均在array内。


Effects can be used within the loop to perform operations with the data within an array
===添加到临时数组(add_to_temp_array)===
{{SVersion|1.10}}


=== add_to_temp_array ===
与<code>add_to_array</code>代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。
{{SVersion|1.9}}


Same as <code>add_to_array</code> but for temporary arrays that expire once execution of the script is finished.
===从临时数组中移除(remove_from_temp_array)===
{{SVersion|1.10}}


=== remove_from_temp_array ===
与<code>remove_from_array</code> 代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。
{{SVersion|1.9}}


Same as <code>remove_from_array</code> but for temporary arrays that expire once execution of the script is finished.
===清空临时数组(clear_temp_array)===
{{SVersion|1.10}}


=== clear_temp_array ===
与<code>clear_array </code> 代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。
{{SVersion|1.9}}


Same as <code>clear_array </code> but for temporary arrays that expire once execution of the script is finished.
===重置临时数组规模(resize_temp_array)===
{{SVersion|1.10}}


=== resize_temp_array ===
与<code>resize_array</code> 代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。
{{SVersion|1.9}}


Same as <code>resize_array</code> but for temporary arrays that expire once execution of the script is finished.
==触发器(Triggers)==
{{SVersion|1.10}}


== Triggers ==
===包含关系(is_in_array)===
{{SVersion|1.9}}
{{SVersion|1.10}}


=== is_in_array ===
<pre>
{{SVersion|1.9}}
is_in_array = {
 
array = <name>
<pre>is_in_array = {
value = <value>
   array = <name>
   value = <value>
}
}
</pre>
</pre>


Checks if the specified value is in the specified array.
检测指定数组array是否含有指定元素value。


=== any_of ===
=== 存在量词(any_of)===
{{SVersion|1.9}}
{{SVersion|1.10}}


<pre>any_of = {
<pre>
   array = <name>
any_of = {
   value = <string>
array = <name>
   index = <string>
value = <string>
  
index = <string>
   <triggers>
<triggers>
}
}
</pre>
</pre>
对指定数组内的每一元素调用<triggers>并比较触发器输出和元素值。如果任一比较结果值为真则触发器输出为真,否则为假。


Runs a loop on the specified array and checks the triggers against the current element. If any return true, the whole check returns true, otherwise returns false.
===全称量词(all_of) ===
{{SVersion|1.10}}


=== all_of ===
<pre>
{{SVersion|1.9}}
all_of = {
 
array = <name>
<pre>all_of = {
value = <string>
   array = <name>
index = <string>
   value = <string>
   index = <string>
<triggers>
  
   <triggers>
}
}
</pre>
</pre>
对指定数组内的每一元素调用<triggers>并比较触发器输出和元素值。如果任一比较结果值为假则触发器输出为假,否则为真。


Runs a loop on the specified array and checks the triggers against the current element. If any return false, the whole check returns false, otherwise returns true.
=== 作用域存在量词(any_of_scopes)===
 
{{SVersion|1.10}}
=== any_of_scopes ===
{{SVersion|1.9}}


<pre>
<pre>
any_of_scopes = {
any_of_scopes = {
   array = <name>
array = <name>
  
   <triggers>
<triggers>
}
}
</pre>
</pre>
对指定数组进行循环操作,将<triggers>与当前作用域进行比较,如果任一返回值为真则触发器输出为真,否则为假。


Runs a loop on the specified array and checks the triggers against the current element scope. If any return true, the whole check returns true, otherwise returns false.
=== 作用域全称量词(all_of_scopes)===
 
{{SVersion|1.10}}
=== all_of_scopes ===
{{SVersion|1.9}}


<pre>
<pre>
all_of_scopes = {
all_of_scopes = {
   array = <name>
array = <name>
  
   <triggers>
<triggers>
}
}
</pre>
</pre>


Runs a loop on the specified array and checks the triggers against the current element scope. If any return false, the whole check returns false, otherwise returns true.
对指定数组进行循环操作,将<triggers>与当前作用域进行比较,如果任一返回值为假则触发器输出为假,否则为真。
 
==附加信息==
{{SVersion|1.10}}
你可以将某数组内变量的数目输出出来,只需要这么写:<code>set_variable = { var_name = array_name^num }</code> 。


== Examples ==
== 例子 ==
{{SVersion|1.9}}
{{SVersion|1.10}}


{{Modding navbox}}
{{Modding navbox}}
[[Category:Modding]]
[[ 分类:Modding]]

2022年12月5日 (一) 15:33的最新版本

数组是《钢铁雄心IV》中用以存储变量的方式,变量既可以是数字形式numerical data的,也可以是作用域scope data形式的。

数组在指令effects中发挥作用,并且触发器trigger能够从中读取数据。指令既可以使数组迭代入其他指令,也能使其数据在自身内进行迭代。

以下,使用<>括起的内容为数据类型,等号左侧的标识符为参数名称

指令(Effects)

添加到数组(add_to_array)

add_to_array = {
    array = <name>
    value = <value>
    index = <index>
}

一旦将元素添加到数组中,就会创建一个数组。

array 是数组的名称,也是指令和触发器调用它的依据。

value 是指要加入数组的数据内容,它既可以是数字形式的(如1 或 var:my_num),也可以是作用域形式的(如GER 或 var:my_scope)。这些都是选填内容,如果不填,则会将当前作用域填入此处。

index 指数据内容应当被插入数组的哪个位置。缺省default data(现普遍称默认)情况下,value会接续在数组最后。其他情况下,原有的数据会自动向后移位以适应插入。

这部分的简便写法是:add_to_array = { <name> = <value> }

从数组中移除(remove_from_array)

remove_from_array = {
	array = <name>
	value = <value>
	index = <index>
}

array 是将被移除数据的数组名称。

value 是想要移除的数据内容。

index 指移除操作所选择的开始位置。

如果value和index都未定义,那么array只有最后一个元素会被移除。

这部分的简便写法是:remove_from_array = { <name> = <value> }

清空数组(clear_array)

clear_array = <name>

清空指定数组。

重置数组规模(resize_array)

resize_array = {
	array = <name>
	value = <value>
	size = <int>
}

重置特定数组array的规模(size)。

如果扩大现有数组的规模,多出来的新元素将被置为value;如果缩小现有数组的规模,则自index=size开始的元素将被丢弃。

这部分的简便写法是: resize_array = { <name> = <size> }

while循环指令(while_loop_effect)

while_loop_effect = {
	break = <string>
	limit = { <triggers> }
	
	<effects>
}

对指定数组进行有条件的循环操作。只要limit为真,就重复执行指令组(用花括号括起的指令集合)。

break接受一个临时变量temp variable,当传递给break的变量取值为非0时,迭代将结束。缺省情况下,break接受的变量名为 break。break无法在本指令之外被访问。

本指令接受指令组作为其参数,以指定对数组元素进行的操作。

该指令会隐性地将当前数组array作为参数。

for each循环指令(for_each_loop)

for_each_loop = {
	array = <name>
	value = <string>
	index = <string>
	break = <string>
	
	<effects>
}

对指定数组中的每个元素调用指令组。

value指定了一个临时变量,指向迭代过程中的当前元素,缺省值为v

index指定了一个临时变量,指向迭代过程中的当前位置,缺省值为i

break后应分配一个非零临时变量以结束迭代,缺省值为break

在此循环中可以写入指令执行某些操作,并隐性地以当前数组为参数

for each作用域循环指令(for_each_scope_loop)

for_each_scope_loop = {
	array = <name>
	break = <string>
	
	<effects>
}

对指定数组中的每个元素调用指令组,并且在每次调用时将当前作用域更改为当前元素。

break后应分配一个非零临时变量以结束迭代,缺省值为break

在此循环中可以写入指令执行某些操作,并隐性地以当前数组为参数

随机作用域指令(random_scope_in_array)

random_scope_in_array = {
	array = <name>
	break = <string>
	limit = { <triggers> }
	
	<effects>
}

对特定的数组中的每一变量进行循环操作,并在每次迭代时将当前作用域改为随机作用域(当前数组内的一个随机的、不同于当前作用域的变量)。

break后应分配一个非零临时变量以结束迭代,缺省值为break

在此循环中可以写入指令执行某些操作,所用的数据内容应均在array内。

添加到临时数组(add_to_temp_array)

add_to_array代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。

从临时数组中移除(remove_from_temp_array)

remove_from_array 代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。

清空临时数组(clear_temp_array)

clear_array 代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。

重置临时数组规模(resize_temp_array)

resize_array 代码相同,但存储对象为临时数组,此数组在脚本结束后就会消失。

触发器(Triggers)

包含关系(is_in_array)

is_in_array = {
	array = <name>
	value = <value>
}

检测指定数组array是否含有指定元素value。

存在量词(any_of)

any_of = {
	array = <name>
	value = <string>
	index = <string>
	
	<triggers>
}

对指定数组内的每一元素调用<triggers>并比较触发器输出和元素值。如果任一比较结果值为真则触发器输出为真,否则为假。

全称量词(all_of)

all_of = {
	array = <name>
	value = <string>
	index = <string>
	
	<triggers>
}

对指定数组内的每一元素调用<triggers>并比较触发器输出和元素值。如果任一比较结果值为假则触发器输出为假,否则为真。

作用域存在量词(any_of_scopes)

any_of_scopes = {
	array = <name>
	
	<triggers>
}

对指定数组进行循环操作,将<triggers>与当前作用域进行比较,如果任一返回值为真则触发器输出为真,否则为假。

作用域全称量词(all_of_scopes)

all_of_scopes = {
	array = <name>
	
	<triggers>
}

对指定数组进行循环操作,将<triggers>与当前作用域进行比较,如果任一返回值为假则触发器输出为假,否则为真。

附加信息

你可以将某数组内变量的数目输出出来,只需要这么写:set_variable = { var_name = array_name^num }

例子