Arrays:修订间差异

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


 数组 (Arrays)通常是储存数据的文件。 《钢铁雄心Ⅳ》 中,数 可以 存储定值 据和变值 数据。
 数组在{{ruby|'''指令'''|effects}} 发挥作用 并且{{ruby|'''触发器'''|trigger}}能够从中读取 据。指令既 可以 使 组迭代入其他指令,也能使其 数据 在自身内进行迭代


  数组可 在游戏中出现一些效果 可以触发它们来检查它们。有些特殊 功能允许重复将同一个 组或者其中 部分 据用于其他的效果
 以 使用<>括起 内容为''' 据类型''',等号左侧 标识符为'''参 名称'''
== 指令(Effects)==
{{SVersion|1.10}}


== 效果 ==
=== 添加 数组 (add_to_array)  ===
{{SVersion|1.9}}
{{SVersion|1.10}}
 
=== 添加数组 ===
{{SVersion|1.9}}


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


  创建一个 数组 并写入内容 。 
array 数组 的名称,也是指令和触发器调用它的依据


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


<value>是你要添加到 数组的数 它可以是定值 字(i.e. 1 or var:my_num) 或者一个范围 (i.e. GER or var:my_scope).这可以 己选择,如果不包括,那么可 把作用范围写 <value>
index 指数据内容应当被插入 数组的 哪个位置。{{ruby|'''缺省'''|default data}}(现普遍称'''默认''')情况下,value会接续在 组最后 其他情况下,原有的 据会 动向后移位 适应插


<index> 是表示这个<value> 应被插入这个数组的位置。一般情况下会被插入这个数组的末端,否则这个数据会被移动来容纳新的<value
这部分的简便写法是:<code>add_to_array = { <name> = <value> }</code>


一个比较短的表达式: <code>add_to_array = { <name> = <value> }</code>
=== 从数组 移除 (remove_from_array) ===
 
{{SVersion|1.10}}
=== 从数组移除 ===
{{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 是将被移除数据的数组名称。


<name> 从中 移除数据 的数组
value  要移除 数据 内容


<value>是你想从这个数组中 移除的 值 如果有的话t).
index 指 移除 操作所选择 '''开始'''位置。


<index>是你想从这 数组中 移除 的索引(index) (如果有的话).
如果value和index都未定义,那么array只有最后一 元素会被 移除


  如果没有确定<value> <index> ,那么最末尾的那个就会被移除
  这部分的简便写法是:<code>remove_from_array = { <name> = <value> }</code>


一个较短的表达式: <code>remove_from_array = { <name> = <value> }</code>
=== 清 数组 (clear_array) ===
 
{{SVersion|1.10}}
=== 清 数组 ===
{{SVersion|1.9}}


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


 清 指定数组 中的所有数据
 清 指定数组


===  调整 数组 ===
===  重置 数组 规模(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)。


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


<value> 是写入这个数组的值。如果没有指定一个值,那么会自动设为0
这部分的简便写法是: <code>resize_array = { <name> = <size> }</code>


<size>用于写入新数据的大小, 删除或缩小数组中的数据,或者添加有 定的值的新数据
===while循环 令(while_loop_effect)===
{{SVersion|1.10}}


一个较短的表达式: <code>resize_array = { <name> = <size> }</code>
<pre>
 
while_loop_effect = {
=== 循环效果 ===
break = <string>
{{SVersion|1.9}}
limit = { <triggers> }
 
<pre>while_loop_effect = {
<effects>
   break = <string>
   limit = { <triggers> }
  
   <effects>
}
}
</pre>
</pre>
对指定数组进行有条件的循环操作。只要limit为真,就重复执行指令组(用花括号括起的指令集合)。


触发条件正确即触发效果 。 
break接受一个{{ruby|'''临时变量'''|temp variable}},当传递给break的变量取值为'''非0'''时,迭代将结束。缺省情况下,break接受的变量名为 <code>break</code>。break无法在本指令之外被访问


<break>填入一个临时的变量 设置为不为0 数以停止循环 默认是 <code>break</code>.
本指令接受指令组作为其参数 ,以 指定对数组元素进行 操作


  重复的效果可以通过一个 组中的 据表现出 。 
  该指令会隐性地将当前 组array作为参 数。


=== 每一次 ===
===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>
对指定数组中的每个元素调用指令组。


指定 数组 每个数据执行循环 。 
value 指定 了一个临时变量,指向迭代过程中 当前元素,缺省值为<code>v</code>


<value>写入 一个临时 变量, 在循环时会储存 当前 。默认是 <code>v</code>.
index指定了 一个临时变量, 指向迭代过程中的 当前 位置,缺省 <code>i</code>


<index> 写入 一个临时 变量, 在循环时储存当前的顺序索引,默认是 <code>i</code>.
break后应分配 一个'''非零''' 临时变量 以结束迭代 缺省值为<code>break</code>


<break>填 一个临时的变量 设置 不为0的 以停止循环。默认是 <code>break</code>.
在此循环中可以写 指令执行某些操作 并隐性地 当前数组


重复的效果可以通过一个数组中的数据表现出。
===for each作用域循环指令(for_each_scope_loop)===
{{SVersion|1.10}}


=== 每一次作用范围的循环 ===
<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>
对指定数组中的每个元素调用指令组,并且在每次调用时将当前作用域更改为当前元素。


给指定数组的每 数据执行循环 并在循环时储存当前数据范围
break后应分配一 '''非零'''临时变量以结束迭代 缺省值为<code>break</code>。


<break>填 一个临时的变量 设置 不为0的 以停止循环。默认是<code>break</code>.
在此循环中可以写 指令执行某些操作 并隐性地 当前数组


重复的效果可以通过一个数组中的数据表现出。
===随机作用域指令(random_scope_in_array) ===
{{SVersion|1.10}}


=== 数组中的随机范围 ===
<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>
对特定的数组中的每一变量进行循环操作,并在每次迭代时将当前作用域改为随机作用域(当前数组内的一个随机的、不同于当前作用域的变量)。


给指定数组的每 数据执行循环 并随机更改数据范围 满足触发条件的范围(在数组内写的范围外)
break后应分配一 '''非零'''临时变量以结束迭代 缺省值 <code>break</code>。


<break>填 一个临时的变量 可以设置为不为0 的数 以停止循环 默认是<code>break</code>.
在此循环中可以写 指令执行某些操作 所用 的数 据内容应均在array内


重复的效果可以通过一个 数组 中的数据表现出。
===添加到临时 数组 (add_to_temp_array)===
{{SVersion|1.10}}


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


跟<code>add_to_array (添加数组)</code>  一样,但是是在效果执行完后就过期的 临时数组
===从 临时数组 中移除(remove_from_temp_array)===
{{SVersion|1.10}}


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


跟 <code>remove_from_array(从数组中移除)</code> 一样,但是是在效果执行完后就过期的 临时数组
===清空 临时数组 (clear_temp_array)===
{{SVersion|1.10}}


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


跟<code>clear_array (清除数组)</code> 一样,但是是在效果执行完后就过期的 临时数组
===重置 临时数组 规模(resize_temp_array)===
{{SVersion|1.10}}


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


跟<code>rese_array(调整数组 </code>  一样,但是是在效果执行完后就过期的临时数组
==触发器(Triggers ==
{{SVersion|1.10}}


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


=== 在数组中 ===
<pre>
{{SVersion|1.9}}
is_in_array = {
 
array = <name>
<pre>is_in_array = {
value = <value>
   array = <name>
   value = <value>
}
}
</pre>
</pre>


 检 指定 的指 是否 指定 的数组中
 检 指定 数组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>并比较触发器输出和元素值。如果任一比较结果值为真则触发器输出为真,否则为假。


在指定的数组中运行循环,并检查当前数据的触发条件. 如果任意回馈是正确的,那么要检查的所有都是正确的。反之则是错误的
===全称量词(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>并比较触发器输出和元素值。如果任一比较结果值为假则触发器输出为假,否则为真。


在指定的数组中运行循环,并检查当前数据的触发条件.如果任意回馈是错误的,那么要检查的所有都是错误的。反之则是正确的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 }

例子