Welcome to A!Die Software Studio

首页 | 作品 | 资料 | 工具 | 关于 | 留言

阿呆软件工作室 › 编程资料 › 翻译文章 › X3:Reunion 脚本编写指南

X3:Reunion 脚本编写指南

翻译: adie
日期: Oct,2011
原文作者: Cycrow
原文标题: Cycrow's Scripting Guide
原文地址: http://cycrow.thexuniverse.us/scripts/help/

下载 PDF 版

启动脚本编辑器手把手的教你如何在游戏中使用脚本编辑器.
创建第一个脚本一步一步的指导你创建一个可用的脚本.
添加命令 -- 修改金钱一步一步的讲解如何添加脚本命令, 以增加玩家的金钱作为例子.
运行脚本学习如何手动运行脚本.
使用要多个参数的命令 -- 声望修改了解如何在脚本中选择和编辑参数, 这个例子展示了如何增加某个种族的声望.
创建语言文件学习如何创建包含字符串资源的外部文件, 并且在脚本编辑器中加载这些字符串资源.
使用命令插槽介绍了如何使用命令插槽来把你的脚本添加到飞船或空间站的菜单里面去.
条件语句介绍了 if, else/if, while, skip if 这些语句的使用.
脚本参数介绍了脚本参数的用途.
创建物品如何创建在游戏中使用的物品, 包括使用内建的, EMP, 以及 Plugin Manager 的方式来创建.
使用快捷键学习如何使用快捷键, 实例程序实现了通过快捷键来摧毁目标. 这里也介绍了全局变量和安装脚本的一些东西.
AL插件学习如何使用基本的 AL 插件来启用和禁用你的脚本.
字符串使用作为从语言文件中载入字符串的后续, 你将看到如何在脚本中创建包含变量内容的字符串.
交互问卷介绍了如何创建问卷形式的交互界面, 以及菜单系统的实现.
附录: 命令列表(由Boron Ol Fh'art提供)

启动脚本编辑器

在主菜单中选择 "personal"(个人信息) 菜单:

然后选择 "pilot"(飞行员) 菜单:

最后选择 "Rename"(重命名) 选项:

现在输入 "Thereshallbewings" 作为你的名字, 注意 "T" 必须大写, 还有这里有两个 "l"

游戏会卡一下, 之后脚本编辑器就启用了.现在你只需要保存你的游戏, 并在加入了新脚本后重新载入你的游戏.

创建第一个脚本

进入脚本编辑器

进入后会看到一个文件的列表, 选择最上面的 "new script"(新建脚本) 选项

然后输入脚本的名字, 这也是你编辑的脚本的文件名

进入代码区域, 选中 "new line"(新建一行) 项

按回车键进入脚本命令菜单

添加命令 -- 修改金钱

在脚本命令菜单中选择 "Trade commands"(交易命令) 项

再选择 "add money to player"(为玩家添加金钱) 项

然后你会看到一个让你输入第一个参数的对话框, 在这个命令中它是要添加的金钱数量, 这里我们选择 "number"(数字) 那一项

输入你想要的数量

完成后, 这个命令会显示在编辑区域中, 现在只需要按 ESC 键来关闭窗口并保存脚本

运行脚本

向下滚动脚本列表, 找到你刚才创建的脚本

选中你创建的脚本后它会变成高亮状态, 按 "r" 键来运行你的脚本

接下来, 游戏将会询问你在哪个对象上运行你的脚本, 对象包括飞船或者空间站, 在这个脚本中, 我们不需要特定的对象, 只需要选择 "null" 即可.

然后, 游戏将会显示你要执行的脚本, 敲回车就行了, 之后脚本就会开始运行

使用需要多个参数的命令 -- 声望修改

在脚本命令菜单中选择 "Global Object Commands"(全局对象命令)

选择 "add notoriety"(增加声望) 项

现在该输入第一个参数了, 第一个参数是你想要增加声望的种族, 我们使用 "Select Race"(选择种族) 按钮来进行选择

在列出来的种族列表中选择你想增加声望的种族, 比如 Argon

完成之后回到脚本编辑器, 但是这里还有其他参数需要设置

使用键盘上的左右方向键来选择你要改变的参数, 然后按回车, 这里我们选择第二个参数

这个参数表示要给谁增加声望, 我们当然是给自己增加声望了, 这就需要使用 "Player" 种族. 不过在列表中并没有 "Player" 这项, 而是显示的飞行员的名字. 选择这个名字, 在脚本中它会自动变成 "Player" 的. [adie: 原文这里还有一句 Goto "Select Race" again then choose "Argon" 应为笔误, 直接删除了没有翻译.]

现在只剩下最后一个参数了, 它表示要添加的声望数量

选择 "<Number>"(数字) 项

输入要增加的声望点数, 通常为 1 到 40

现在这个脚本就完成了, 用 ESC 键保存并退出, 以后当你想要提升 Argon 的声望时就运行这个脚本吧

创建语言文件

[adie: 语言文件的原文是 "Text File", 直译的话叫文本文件, 但这样的称呼太笼统了, 而作者的意思应该是表示一种包含了游戏中使用的字符串文本资源的文件. 这个文件格式其实是 XML 的, 并且游戏支持的每种语言都有一份, 其作用就是为了把游戏中用到的字符串集中到一起, 便于翻译出不同语言的版本, 所以我这里就把它翻译成 "语言文件" 了.]

语言文件包含了游戏中需要的所有文本, 比如命令, 商品名字等.

要创建语言文件, 你首先需要获得一个 ID 号(FILE_ID), FILE_ID 通常是一个 7000 到 9000 之间的 4 位数字. 在 egosoft(X3的开发团队) 的网站上列出了现有脚本所使用的 FILE_ID, 你最好选择一个上面没有的, 以避免和现有的脚本冲突. 点击这里查看 FILE_ID 列表.

[adie: 不明白为什么要设计这么一个 ID, 其实完全可以用一个字符串来标示, 这样脚本开发者们就可以用 "组织名+功能名" 的方法来避免冲突了. 接下来的部分会有好几种不同的 ID, 为了清晰, 这些 ID 都用英文简写来描述, 并先做一些介绍:

LANG_ID, language id, 语言 ID. 在游戏中用于标识使用的语言, 其实是各个地区的电话号码的区号, 英国 44, 中国 86, 德国 49... 更多号码参考这里.
FILE_ID, text file id, 语言文件 ID. 为每一个资源文件分配的 ID. 同一个 ID 的文件包含的文本意义应该是相同的, 但是使用的语言可能不同. 是字符串资源的物理分组.
PAGE_ID, page id, 页面 ID. 用来标识一组字符串, 这组字符串也可能是从好几个不同的文件中加载起来的. 是字符串资源的逻辑分组. 一个分组称为 page, 下面的翻译中的 "页面" 即指的一个这样的分组.
TEXT_ID, text id, 字符串文本 ID. 用来标识一个页面中具体的某一个字符串. 由于是在页面中的, 所以只需要在同一个 PAGE_ID 下的没有重复即可.

]

现在可以开始创建文件了, 文件名必须是 LANG_ID 加上你刚刚选择的 FILE_ID. 英语的 LANG_ID 是 44, 如果你获得的 FILE_ID 是 9000, 那么文件名就是 "449000.xml", 另外你还需要把文件放到 x3/t 目录下.

你可以用任何你喜欢的文本编辑器(比如记事本)来编辑这个文件, 文件的第一行基本上都是这样的:

<?xml version="1.0" encoding="UTF-8" ?>

这样表示了你的文件是一个使用 utf-8 编码的 xml 文件, utf-8 编码包含了其它语言(比如俄语)中的特殊字符, 这样才能让其它语言也正常显示.

接下来的一行是 LANG_ID, 在文件名中使用过的, 英语为 44.

<language id="44">

文件中的其余部分需要按分页的方式来组织, 每一页都有一个 ID (PAGE_ID), 脚本编辑器中将使用 PAGE_ID 来加载对应的页面内容.

有一些 PAGE_ID 是有特殊含义的, 他们被用来添加命令或是物品. 这里我们只是添加点文本给脚本用, 可以按照获得 FILE_ID 的方法来获得 PAGE_ID. PAGE_ID 通常也在 7000 到 9000 之间, 所以使用 FILE_ID 来作为 PAGE_ID 是个很不错的注意. 下面是开始一个页面的代码:

<page id="9000" title="my script text">

其中的 title 参数主要是作为参考, 不是必须的. 在页面里面就是一条一条的字符串了, 每个字符串都有它们自己的 ID (TEXT_ID). 它们被放到 t 标签中.

<t id="1">Some text</t>

注意末尾的 </t> 结束标签. 像 HTML 文件一样, 所有的标签都必须被关闭. 因此, 我们需要关闭 page 标签.

</page>

你还可以根据情况添加更多的 page 标签. 在文件的最后, 我们需要关闭 lauguage 标签.

</language>

现在, 你已经做好了语言文件了. 完整的文件如下:

<?xml version="1.0" encoding="UTF-8" ?>
<language id="44">
    <page id="9000" title="my script text">
        <t id="1">Some text</t>
    </page>
</language>

然后, 我们还需要从游戏中的脚本编辑器来访问这些字符串.

首先要做的是把语言文件加载到游戏中来, 这通常都是通过名字以 setup 开头的脚本文件来自动运行的. 如果你喜欢, 你也可以用其它名字, 然后手动运行它. 创建一个新脚本, 然后从 "General Commands"(普通命令) 中选择 "load text:id" 命令: [adie: 原文误为 load id ]

这里只有一个 "number"(数字) 类型的参数, 表示要加载的文件的 ID (FILE_ID), 我们这里使用的是 9000, 所以选择 "number"(数字) 然后输入 9000.

这样安装脚本就制作完了, 在游戏载入的时候我们的语言文件也会被载入了. 要使用里面的字符串, 需要用到 "General Commands"(普通命令) 中的 "read text" 命令.

第一个参数是返回值, 它要求使用一个变量, 字符串会被保存到这个变量里面. 选择 "varible"(变量) 然后输入变量名. 在这个例子中, 我使用 "message" 作为变量名. 之后就会创建出一个 $message 变量来存储语言文件中的字符串.

下一个参数是 PAGE_ID, 表示了你要加载的字符串所在的页面. 我们刚刚添加的语言文件页面的 PAGE_ID 是 9000. 语言文件加载的时候, 整个文件都会被读入内存中, 如果你的一些文件中有相同的页面, 它们会互相覆盖. 使用 "read text" 时, 游戏会查找所有加载了的语言文件来获得正确的页面.

最后一个参数是 TEXT_ID, 也就是文件里面 t 标签中的 ID, PAGE_ID 为 9000 时, TEXT_ID 设为 1 就会返回 "Some Text" 字符串了.

[adie: 原文中上面的贴图也贴错了, 还是贴的 id 为红色问号的图.]

现在 $message 变量中应该已经包含字符串 "Some Text" 了, 为了验证一下, 我们把它写到 logbook(航行日志) 中. 在 "Logbook Commands"(航行日志命令) 菜单中选择 "write to player logbook"(写入玩家日志) 命令.

唯一的参数就是要写入到 logbook(航行日志) 中的文本, 我们使用刚刚创建的变量. 在变量列表中选择 "message".

运行这个脚本后, 就可以在 logbook(航行日志) 看到 "Some Text" 这个字符串了.

使用命令插槽

如果你想让你的脚本和某个命令菜单(command menus, 比如 special, combat, trade 等)关联起来, 那你就需要使用一个游戏的命令插槽了.

首先, 你需要选择一个插槽, 每一种类型的命令下面都有 64 个插槽. 在 egosoft 的论坛上有一份列表, 里面有所有可用的插槽, 以及现有的脚本使用了哪些. 所以, 你在选择命令插槽的时候最好先检查一下这份列表.

到这里去查找可用的命令插槽吧, 下面是它们的类型:

Command Name	ID	Description
COMMAND_TYPE_NAV_??	2	导航命令, 显示在 Navigation(导航) 菜单中
COMMAND_TYPE_FIGHT_??	3	战斗命令, combat 菜单中
COMMAND_TYPE_TRADE_??	4	贸易命令, trade 菜单中
COMMAND_TYPE_SPECIAL_??	5	特殊命令, special 菜单中
COMMAND_TYPE_PIRACY_??	6	非法命令(piracy), 原版游戏中不会用到, 但是许多脚本会用它
COMMAND_TYPE_CUSTOM_??	7	自定义命令, customs 菜单中
COMMAND_TYPE_GENERAL_??	8	普通菜单(general), 作弊脚本使用的地方
COMMAND_TYPE_TURRET_??	9	炮塔命令, 像 X2 中的 AEGIS 一样
COMMAND_TYPE_STATION_??	11	空间站命令, 空间站的命令菜单中出现
COMMAND_TYPE_SHIP_??	12	飞船额外命令, 脚本最常用的, 不会激活飞船的自动驾驶(autopilot)

你应该首先确定命令的类型, 然后再选择对应的插槽, 最好是选择别人没有用过的, 否则你的脚本就会和其它的脚本不兼容. 插槽编号通常在 16 到 63 之间, 小于 16 的是游戏保留有特殊用途的.

选好了插槽后你就可以把它加入到游戏中了, 这是通过在语言文件中添加特殊的文本项来完成的.

这里是一个例子, 它选择了一种命令类型后用 40 作为插槽编号.

每一个命令插槽都有一个 ID, 通常是 3 到 4 位数. 末尾两位是你选择的插槽编号, 这个例子中为 40. 前面的部分代表了命令的类型, 比如导航(navigation)命令是 2, 编号为 40 的插槽 ID 就是 240. 其余类型的命令分别是: Fight = 3, Trade = 4, Special = 5, Piracy = 6, Custom = 7, General = 8, Turret = 9, Station = 11, Ship = 12.

<?xml version="1.0" encoding="UTF-8" ?>
<language id="44">
  <page id="2008" title="Script Cmd Names" descr="">
    <t id="240">COMMAND_TEST_TRADE_COMMAND</t>
  </page>

  <page id="2010" title="Script Cmd Names" descr="">
    <t id="240">Test Trade Command</t>
  </page>

  <page id="2011" title="Script Cmd Shorts" descr="">
    <t id="240">Test</t>
  </page>
</language>

你需要为你的命令插槽创建 3 个页面, 第一个是 PAGE_ID 为 2008 的, 这里面写的是命令的名字, 也就是脚本引擎显示的你的命令时所用的名称. 如果你省略了这个页面, 它会显示一个默认值, 比如 COMMAND_TYPE_NAV_40.

这就是从脚本编辑器中选择命令时的样子. 如果使用了上面的语言文件, 命令就会变成 COMMAND_TEXT_TRADE_COMMAND:

你可以把上面的名字改成任何你喜欢的, 最好是让它能描述出命令的功能, 这样选择命令时就更容易判断出你选择的是什么命令了.

下面一个是 PAGE_ID 为 2001 的页面, 它是命令的主要名字, 就是你在游戏中使用命令时看到的名称.

最后一个是 PAGE_ID 为 2002 的, 他是命令的缩写, 显示在命令主要名字右边的方括号中的名称.

还有一个也许有用的页面, PAGE_ID 是 2022, 它里面可以放一段关于命令的描述. 有了这个描述后, 在显示的命令名字后面会有一个字符 "i", 当你按 "i" 键的时候就会显示你这段命令描述了.

把命令的显示完成后, 下一步就是创建使用这个命令的脚本了. 这至少需要两个脚本. 第一个为命令脚本, 是激活命令后要运行的脚本. 另外一个是安装脚本, 它用来向游戏注册命令脚本, 让命令在游戏中可用. 还有一个可选的脚本是用来检查命令是否可用的, 在判断是否显示命令的时候会调用这个脚本.

编写命令脚本时, 改变上面的 "Command Name"(命令名称) 设置, 就可以改变在正在运行这个脚本的飞船的状态显示. 选择 "Command Name" 项, 滚动到你的命令名字后选中它.

[adie: 注意这个截图和前一个截图中的 Command Name 的变化]

现在, 这个脚本在运行的时候, 这个名字就会显示在飞船的状态那里. 比如, 在你的财产界面中(your owned property menu), "Current Orders"(当前指令) 那一列上就会显示你的命令名称.

在你的脚本运行完后, 它会重置成 "None".

最后, 你还需要创建一个安装脚本来让你的命令可以使用. 这个脚本名字最好用 "setup" 开头, 这样游戏启动的时候就会自动执运行它了. 在这里我使用的名字为 setup.test.command. 脚本里面要使用的第一个命令就是 "General Commands"(普通命令组) 中的 "set script command upgrade"(设置命令等级) 命令.

第一个参数就是我们添加的命令, 选择 "Select Command/Signal"(选择命令/信号) 项:

选择我们所添加的那条命令

第二个参数是需要的等级, 这通常是指某种物品, 或是某种提升等级的东西(upgrade, 就是飞船需要安装的某些升级系统, 在 Equipment Dock 可以看到很多, 比如 Navigation Software MK1 这种.), 这是命令能够使用的前提条件. 把它设置成 Navigation Software MK1(一级导航软件) 就意味着这个命令只有在安装了 Navigation Software MK1 的飞船上才会显示. 把它设置成 [TRUE] 可以让这个命令一直显示.

需要添加的第二个命令设置了我们的命令要使用的脚本, 它也在 "General Commands"(普通命令组) 中, 是 "global script map: set"(设置全局脚本映射) 命令.

第一个参数又是我们添加的命令

第二个参数是命令可用的类别, 比如, 要让这个命令只在 M6 上可用, 你可以选择 M6. 要让所有飞船都可用, 在 "Select Object Class"(选择目标类型) 中选择 "Ship"(飞船) 就可以了.

第三个参数是脚本工作的种族, 我们选择 Player(玩家) 族就好了.

第四个参数是要运行的脚本, 这里我们选择刚才创建的 "test.command".

最后一个参数是优先级, 通常设置为 1 就足够了. 如果还有其它脚本也使用了这个命令插槽, 只有优先级最高的才会生效. 由于作弊脚本使用的是 0, 设置为 1 将会让你的脚本取代作弊脚本.

这个脚本到这里就完成了. 在运行完安装脚本(不管是手动运行还是重新加载游戏来让它自动运行) 之后你添加的命令就可以使用了.

条件语句

条件语句用来控制脚本的逻辑, 他让你可以选择在不同的条件下执行不同的命令.

主要的条件语句是 if 和 while 语句块, 另外还有只对后面的一个命令起效的 skip if 语句.

if 语句
skip if 语句
else 语句
else if 语句
while 语句
条件组合

if 语句

添加 if 语句时, 你必须按块来创建, 并且用 "end" 命令来结束它.

要创建 if, 你还得使用表达式才行.

选了 "if" 命令后, 接下来:

然后你需要填充表达式的部分, 你可以使用许多的命令来进行填充. 一个简单的例子是比较一个变量是否和某个值相等. 第一个变量是你要检查的那个, 这个例子中我们使用 $varible.

下一步, 使用相等命令, 也就是 "==" 命令. 你将使用 "..." 来为表达式添加更多的命令, 并且可以一直加下去.

最后是你要比较的对象, 它可以是另外一个变量(比较两个变量是否一样), 或者是数字, 或者是字符串. 这个例子中我们使用字符串 "test".

现在, 在这个语句下添加的任何命令都只有在 $varible 等于 "test" 这个字符串时才有效, 否则他们会被跳过. 在这个例子中, 我们只是向飞行日志(logbook) 中添加一条消息.

最后我们需要用 "end" 语句来结束 if 块. 它在 "General Commands"(普通命令组) 菜单, "Flow Control"(流程控制) 子菜单下.

这样 if 块就关闭了. 注意在 if 和 end 之间的命令被稍微的缩进了. 你可以在这个块之间创建任意多的命令, 也可以嵌套使用 if 语句块等等.

skip if 语句

skip if 语句和 if 语句差不多, 但是它不使用语句块, 只能使用一个单一命令. 并且当条件判断为真(true)时, 它跳过了下面的命令, 这条命令必须严格的在 skip if 那一行的下面. skip if 语句和 if 语句相反, if 语句下面的命令在条件为真(true)的时候执行, skip if 语句下面的命令在条件为假(false)的时候执行. 要让它的作用和 if 语句一样, 你可以使用 skip if not 语句, 它可以把结果为真(true)的表达式变成结果为假(false).

else 语句

else 语句紧跟在 if 语句后面, 如果 if 的条件为假(false), 将会执行 else 命令块. 要添加 else 命令块, 你需要在把 "else" 命令放到 if 语句中 "end" 命令的位置, 然后把 "end" 命令放到 "else" 命令块结束的地方. 所有在 "else" 和 "end" 之间的命令将会在条件表达式为假(false)的时候执行.

你只能在 if 语句块和 "end" 之间添加一个 "else" 语句.

else if 语句

和 else 命令类似, 你也可以添加 else if 命令. 和 else 不一样的是, 你还可以增加另外一个条件表达式. 下面的例子展示了随机选择一条命令来执行的办法.

你也可以在最后添加一个 "else" 命令, 那样在之前的条件都不为真(true)的时候就会执行这个 "else" 块中的命令了.

只有第一个为真(true)的语句块会被执行.

在上图的例子中, 如果 $rand 为 0, 那么第一和第二个表达式都为真(true). 但是只有第一个命令块会被执行. 在整个命令块中, 它只会选择其中一个分支的语句块来执行.

while 语句

while 语句的工作方式和 if 语句类似, 在最开始的地方使用 while 语句, 在结尾处使用 "end" 语句. 不同的是, 只要条件表达式为真(true), 它就一直重复执行中间的语句块. 你可以使用它来让一个命令执行固定的次数. 创建语句的方法和 if 语句一样, 只是在第一步的时候选择 "while" 命令.

在下面的例子中, 只要 $count 的值大于 0 中间的命令块就会一直运行, 每执行一次, $count 的值就会减少 1, 直到降为 0.

"dec $count =" 命令表示减少变量 $count 的值, 这只在变量的类型是数字时才有效. 因此 $count 的值会从 10 变到 9, 再变到 8 ..., 最终, 你运行完脚本后会在你的飞行日志(logbook)中看到 10 条消息.

条件组合

你可以组合多个条件语句, 比如, 你可以判断两个变量是否等于某个值. 组合条件语句的时候, 你需要在每两个语句之间使用 "AND" 或者 "OR" 命令. 每一个条件语句要么为真(true)要么为假(false), 如果你使用 "AND" 语句, 那么只有当两个语句都为真(true)的时候后面的语句才会执行. 如果使用了 "OR" 语句, 只要其中任意一个语句为真后面的语句就会执行. 你可以组合任意数量的条件语句, 只要保证他们之间用 AND 或者 OR 来分割就可以了.

在这个例子中, $varible1 和 $varible2 都需要是 "test" 字符串才能执行中间的命令.

你可以使用括号来改变条件语句组合的优先级.

在这个例子中, 括号里的条件语句会先被求值. 如果你用 true 或 false 来代替上面的语句, 你会得到类似下面的东西:

if ( true or true ) and true	if ( true ) and true	true
if ( true or false ) and true	if ( true ) and true	true
if ( false or false ) and true	if ( false ) and true	false
if ( false or true ) and false	if ( true ) and false	false

第一列把条件语句用 true 和 false 进行了替换, 第二列去除了括号, 第三列是整个表达式的结果.

你可以使用 "Home" 和 "End" 键来添加和删除表达式中的语句. 如果你创建完整个表达式后想添加括号, 你可以移动光标到让表达式中的变量高亮的位置, 然后按 "Home" 键, 这将会在它之前添加一个命令, 你可以把这个命令设置为括号 (.

脚本参数

在脚本编辑器窗口的上面, 在 version 这类脚本信息的下面, 你可以看到一个叫 "Arguments"(参数) 的区域.

你可以添加任意数量的参数, 你每添加一个, 它就会出现在这个区域的列表中. 选择 "<New Argument>"(新建参数) 可以让你添加一个参数到列表中.

参数用来向脚本传递数据. 当你在另一个脚本中调用这个脚本时, 你可以把使用的变量传递给它.如果是通过命令调用的这个脚本, 它会向用户询问各个参数, 这和你手动运行这个脚本的时候是一样的.

参数包含了 3 个值, 你需要连续的输入他们. 第一个是变量的名字

下一个是参数的类型, 手动运行或通过命令运行脚本时, 这个类型决定了显示什么菜单给用户输入参数. 比如, 设置为 "var/Sector" 会显示星区图给用户选择星区.

最后一个是提示字符串, 选择对象时它会显示在窗口上面, 或者在执行 "call script"(调用脚本) 命令时作为提示.

输入完所有数据之后, 它就被添加到参数列表中了.

你可以再次选择这个参数来编辑它, 也可以用 "Delete" 键来删除它. 要添加另外的参数, 你再次移动到 "<New Argument>"(新建参数) 即可.

运行脚本时, 游戏会询问你每个参数的值. 第一个是你要运行的对象, 这里我们选择 null. 下面就是有效的参数了.

之后, 将会按照参数的顺序让你依次输入每一个参数. 输入的方法由参数的类型来决定.

你可以选择输入 null 或者对应的参数类型, 这里是 Select Ship(选择飞船). 确定要输入一艘飞船作为参数后, 你就需要选择一艘飞船了. 对于这种类型的参数, 你必须先选择一个星区, 然后再选择那个星区里的飞船.

正如你看到的, 选择的方法是由你的参数类型来决定的. 比如类型是 Var/Ware, 你就会看到一个所有可用的物品列表给你选择.

一旦你输入了所有的参数, 脚本就开始运行了.

如果是作为飞船的命令, 它会跳过显示参数的部分, 包括 null 和参数类型的选择. 在这个例子中, 它会直接显示星区图给你选择飞船.

"call script"(调用脚本) 命令

"call script" 命令用来调用另外一个脚本. 命令中已经为你显示了所有需要的参数.

可以看到, 这个字符串参数就是你刚刚输入的: "Select Ship"(选择飞船). 选择它就会出现和手动运行脚本时一样的界面. 你也可以使用变量来代替. 但是, 你无法让它在运行的时候弹出选择界面来让玩家选择这个参数的值, 要实现这样的效果只能是为当前的脚本也添加一个这样的参数.

这样在 $ship 变量中的飞船对象就会传递给被调用的脚本了.

选择创建物品的方法

每种方法都有它的优点和缺点

标准方法: 标准的内建物品有数量限制, 可能会和其它脚本冲突. 他们的价格和声望要求也是固定的, 不能改变. 但是他们不需要安装额外的模块(mod)和程序, 只需要添加脚本就可以了. 和其它方法不不同, 这些物品会被显示在飞船扩展(Ships Extensions)的列表里面. 他们也可以在脚本中使用而不需要要什么额外的东西. 和其它的飞船扩展(ship extensions)一样, 每样物品飞船只能安装一个, 而空间站的库存总是无限的.

EMP: EMP 是一个为游戏添加物品的 MOD(模块), 使用之前你需要先安装它, 所有使用你脚本的用户也需要安装它. 和内建物品一样, 你不可以编辑它的价格和声望, 虽然它也有数量限制, 但是它有更大的范围, 和其它脚本冲突的几率更小. 所有的 EMP 物品都和普通物品一样, 会显示数量为 1. 和内建物品不同, 你可以在一艘飞船上安装多个 EMP 的物品, 但是如果你需要的话, 也可以把它做得像飞船扩展(ship extensions)一样. 另外, 你还需要像工厂里的物品一样手动调整它们的库存.

自定义物品: 自定义物品是 Plugin Manager 提供的一种新特性, 它也可以让你往游戏中添加物品, 要让自定义物品起效, 脚本必须由 Plugin Manager 创建. 和其它方法不同, 你可以自己设置价格, 大小, 数量, 货仓类型, 声望需求等, 你甚至还可以定义它们的外观. 用 Plugin Manager 你可以创建各种类型的物品, 而前面的两种方法只能创建科技升级("tech")物品. 除了你不能在脚本中直接使用它们外其余特性和 EMP 一样: 它们会显示在货仓中而不是飞船扩展(hip extensions)里, 需要手动调整库存. 而且在脚本中使用它们的方法也不一样, 你需要调用其它的的脚本来获取物品对象, 而不是直接使用它们.

方法一: 使用标准的内建物品位置

有几个内建的物品位置可以给脚本使用, 它们只能用来做飞船扩展(ship extensions), 在查看货物列表的时候会显示在扩展(extensions)区域内.

使用内建物品位置最大的麻烦是它们有数量限制, 因此很容易和其它也使用了这个物品位置的脚本冲突. 还有就是限制了物品的价格, 无法修改.

可用的物品位置(slots)如下:

28;0;0;0;0;59;5753;0;35714;1;1;0;35714;-100000;0;0;SS_WARE_SW_NEW1; 1,002,677 credits 
28;0;0;0;0;60;5763;0;17;1;1;0;17;-100000;0;0;SS_WARE_SW_NEW2; 477 credits 
28;0;0;0;0;61;5773;0;14;1;1;0;14;-100000;0;0;SS_WARE_SW_NEW3; 393 credits 
28;0;0;0;0;62;5783;0;56;1;1;0;56;-100000;0;0;SS_WARE_SW_NEW4; 1572 credits 
28;0;0;0;0;63;5793;0;88;1;1;0;88;-100000;0;0;SS_WARE_SW_NEW5; 2470 credits 
28;0;0;0;0;64;5803;0;283;1;1;0;283;-100000;0;0;SS_WARE_SW_NEW6; 7945 credits 
28;0;0;0;0;65;5813;0;383;1;1;0;383;-100000;0;0;SS_WARE_SW_NEW7; 10752 credits 
28;0;0;0;0;66;5823;0;1389;1;1;0;1389;-100000;1043;0;SS_WARE_SW_NEW8; 38,996 credits 
28;0;0;0;0;67;5833;0;3396;1;1;0;3396;-100000;0;0;SS_WARE_SW_NEW9; 95,343 credits 
28;0;0;0;0;68;5843;0;4215;1;1;0;4215;-100000;0;0;SS_WARE_SW_NEW10; 118,336 credits 
28;0;0;0;0;69;5853;0;5635;1;1;0;5635;-100000;0;0;SS_WARE_SW_NEW11; 158,203 credits 
28;0;0;0;0;70;5863;0;65735;1;1;0;65735;-100000;0;0;SS_WARE_SW_NEW12; 1,845,522 credits 
28;0;0;0;0;71;5873;0;17857;1;1;0;17857;333;1043;0;SS_WARE_SW_NEW13; 501,338 credits 
28;0;0;0;0;72;5883;0;21428;1;1;0;21428;0;0;0;SS_WARE_SW_NEW14; 601,595 credits 
28;0;0;0;0;73;5893;0;324515;1;1;0;324515;-100000;0;0;SS_WARE_SW_NEW15; 9,110,822 credits 
28;0;0;0;0;74;5903;0;638508;1;1;0;638508;-100000;0;0;SS_WARE_SW_NEW16; 17,926,236 credits 
28;0;0;0;0;75;5913;0;225755;1;1;0;225755;-100000;0;0;SS_WARE_SW_NEW17; 6,338,115 credits 
28;0;0;0;0;76;5923;0;1931535;1;1;0;1931535;1000;0;0;SS_WARE_SW_NEW18; 54,228,222 credits 
28;0;0;0;0;77;5933;0;2209150;1;1;0;2209150;-100000;0;0;SS_WARE_SW_NEW19; 62,022,317 credits 
28;0;0;0;0;78;5943;0;6727565;1;1;0;6727565;-100000;0;0;SS_WARE_SW_NEW20; 188,877,701 credits

你需要选择一个价格和你想要的价格最接近的, 价格显示在每行的最后一列. 要检查这个位置是否可用, 到 Egosoft 论坛的 Community Scripts Sticky 里去吧, 在里面的 2 楼(the second post)可以找到当前脚本使用了哪些物品位置.

看看上面的其中一行, 你可以为你要添加的物品找到一些信息.

28;0;0;0;0;59;5753;0;35714;1;1;0;35714;-100000;0;0;SS_WARE_SW_NEW1; 1,002,677 credits

在这个物品中, 价格是 1,002,677 credits, 你也可以直接用第 1 列和第 9 列(28 和 35714)相乘来得到价格. 第 7 列是物品名字的 TEXT_ID, 5753, 你需要用它来添加物品. 还有第 14 列, -100000, 是购买这个物品需要的声望.

找到你要使用的物品位置后, 你需要为你的物品创建文本资源. 创建时需要用上面找到的那个 TEXT_ID(比如 5753). 创建一个语言文件, 然后添加 PAGE_ID 为 17 的页面. 之后添加字符串条目, 第一个是物品名字, 第二个是物品描述, 物品描述的 TEXT_ID 就是物品名字的 TEXT_ID 加 1. 物品名字的 TEXT_ID 通常以 3 结尾的. 物品描述的 TEXT_ID 通常是以 4 结尾的.

<?xml version="1.0" encoding="UTF-8" ?>
<language id="44">
  <page id="17" title="wares" descr="0">
    <t id="5753">My Ware</t>
    <t id="5754">My Wares Description</t>
  </page>
</language>

方法二: 使用 EMP 模块

EMP 是由玩家社区开发的一个模块(MOD), 用来向游戏添加物品. 制作 EMP 的初衷是因为标准物品位置的数量限制. 和标准物品一样, 你不能改变价格和其它东西, 你只能选择一个和你想要的最接近的.

首先, 你需要到论坛(Main Forum Page)去下载 EMP, 或者也可以下载它的 SPK版本

如果是下载的模块包(mod package), 里面会有一个列出了所有物品的文本文件. 忽略前面的部分, 直到你看到一个以 SS_WARE_SW_CUSTOM 结尾的分组. 这些都是自定义的物品. 他们被分成很多组, 里面的内容和标准物品一样, 不同的分组之间有不同的声望需求. 在行尾的物品标示都用了两个数字结尾, 比如 SS_WARE_SW_CUSTOM1_1, 其中第一个是物品在组里面的编号, 相当于标准物品的那个, 第二个是组的编号.

28;0;0;0;0;81;10053;0;35714;1;1;0;35714;-10000;0;0;SS_WARE_SW_CUSTOM1_1;

要得到物品的价格, 可以用第 1 列的值(28) 乘以第 9 列的值(35714). 第 14 列, -10000, 是物品的声望需求, 同一组的物品声望需求通常是一样的. 要找你想用的物品时, 先找到声望匹配的组, 然后再去找价格匹配的. 你可以到论坛 EMP 页面(EMP Forum page)去检查你要使用的物品位置有没有被其它脚本使用. 上面的第二页列出了现有脚本所使用的物品. 第 6 列是物品的编号(81), EMP 页面里就是按这个编号来显示的, 所以你需要用这个编号去做检查. 后面那列是物品的 TEXT_ID (10053), 你需要用它来创建语言文件里的文本项.

一旦你选好了物品位置, 你就要为这个物品创建语言文件了, 上面那个 TEXT_ID(10053) 就是用来创建这个的. 创建一个语言文件, 然后添加 PAGE_ID 为 17 的页面. 之后添加字符串条目, 第一个是物品名字, 第二个是物品描述, 物品描述的 TEXT_ID 就是物品名字的 TEXT_ID 加 1. 物品名字的 TEXT_ID 通常以 3 结尾的. 物品描述的 TEXT_ID 通常是以 4 结尾的.

<?xml version="1.0" encoding="UTF-8" ?>
<language id="44">
  <page id="17" title="wares" descr="0">
    <t id="10053">My Ware</t>
    <t id="10054">My Wares Description</t>
  </page>
</language>

方法三: 使用 Plugin Manager 的自定义物品功能

要使用自定义物品, 你需要启动 Script Packager 然后切换到 "Wares"(物品) 选项卡.

在第一个列表框里面点右键, 然后选择菜单中的 "Add Ware"(添加物品).

"Ware ID"(物品标识) 是你在脚本里面访问这个物品时用的, 具体参考它的帮助页面.

这里也需要添加语言文件, 它决定了在游戏里显示的物品名字.

要在游戏里使用这些物品, 你需要使用 Plugin Manager 附带的 "getware" 脚本, 具体名字是 "plugin.scriptmanager.getware", 它需要 1 个参数, 就是上面 Script Packager 里的 Ware ID(物品标识), 比如 SS_WARE_CY_MYWARE 这种. 这个标识的格式和名称并不重要, 不过我建议你加上你的名字或是某种标志, 这样可以防止别人使用和你相同的名字. 比如, 两个脚本里面都包含了助推器(afterburner)的脚本, 他们可能都使用了 SS_WARE_AFTERBURN 这样的名字, 于是就产生冲突了. 因此, 如果你在里面加上你的名字, 这两个脚步就会用不同的标识了(SS_WARE_CY_AFTERBURN).

在脚本中使用物品

按照上面的方法创建了你的物品后, 这些物品就可以在游戏里面使用了. 不过我们还需要在宇宙空间里能够买到这个物品. 通常的做法是把物品加入到空间站里面, 比如 Equipment docks, Trading Stations 等.

要出售物品, 只需要使用一条简单的命令, 它运行在空间站对象上. 你可以在 "General Object Commands" 菜单中找到它.

第一项是空间站对象, 你必须在添加产品之前完成它. 方法有很多, 为了简单, 我们这里使用了一个参数来完成.

最后一个是要添加的产品或物品(product/ware). 如果使用的是标准物品或 EMP, 只需要从物品列表里面选择就可以了, 首先, 把滚动条拉到底部, 选择 "Select Ware"(选择物品) 项, 然后物品列表就出来了. (对自定义物品, 可直接查看这里)

然后选择你添加的那个物品, 名字是你在语言文件中填写的名字. 注意, 你必须保证已经加载了语言文件, 否则是无法正确显示的.

这样命令就添加完了, 你可以运行这个脚本, 然后选择要添加物品的空间站.

对于自定义物品, 情况就有些不同了, 你需要在添加这个命令之前先使用 getware 脚本, 你可以在这个命令的上面插入一行. 方法是在当前命令上按 INSERT 键, 新的一行就插入到当前命令上面了.

现在, 你需要添加 "call script"(调用脚本) 命令, 它在 "General Command"(普通命令) 菜单的 "Script Calls"(脚本调用) 子菜单下.

然后选择要调用的脚本, 我们需要的是 getware 脚本, 即 plugin.scriptmanager.getware.

这样 call script 命令就添加进来了, 第一个参数是脚本的返回值, 对 getware 脚本来说, 它返回的是物品对象.

把它设置成保存物品对象的变量, 比如 ware

接下来的参数是脚本要运行的对象, 这个脚本不需要在某个对象上运行, 使用 [THIS] 就足够了. 最后一个参数是物品的名字, 这就是在 Script Packager 中添加物品时的 Ware ID(物品标识). 你需要选择一个字符串类型的值.

然后输入你的 Ware ID(物品标识), 比如: SS_WARE_CY_MYWARE.

最后, 你需要用 ware 变量来做为产品使用, 修改 add product 命令的参数, 用这个变量来代替那个直接使用的物品.

这里还可以增加一个对物品有效性的检查, 并且我强烈建议你这么做. 如果 Plugin Manager 没有安装这个物品, 你调用的那个脚本就会返回 "null", 因此, 你可以这样检查: 如果它是 null, 你就跳过后面的命令. 你可以在 ware 对象上使用 if 语句或者 skip if 语句.

这样, 当 $ware 无效的时候, 添加物品的命令就会被跳过.

添加物品的脚本库

我已经创建了一些很有用的脚本库, 其中一个就是 lib.cycrow.add.ware. 曾经在 bonus pack 中也有一个叫 lib.cy.add.ware 的, 他们基本一样, 只是版本不同. 这两个脚本用来向一组空间站中添加物品. 比如, 你可以把你的物品添加到所有的 Argon Equipment Docks 中.

要使用这个脚本, 你首先要从这里下载它, 然后把它解压到 X3 的脚本目录中. 然后, 你就可以用 "Call Script" 命令来使用那个脚本了.

这里没有返回值, 也不需要在某个对象上运行, 因此这两个地方随便设置下就好了.

第一个参数是你要添加物品的空间站的类型

第二个参数是空间站的种族, 设置为 Argon 的话就会把物品添加到类型匹配的所有 Argon 的空间站中.

最后一个参数是要添加的物品, 在物品列表中选择吧.

调整库存的脚本库

这些脚本是用来调整你的物品的库存的, 这样就可以保证空间站里你的物品总是有货. 对于标准物品, 这个并不需要, 它们永远也不会卖完的. 但是, 对于 EMP 和自定义的物品, 你需要去保证货物总是能够买到.

从这里下载, 然后把它解压到 X3 的脚本目录里面.

这个包里面有 4 个脚本:

lib.cycrow.keepstock: 这个脚本完成实际的保证库存工作
lib.cycrow.keepstock.add: 这个脚本用来把物品添加到需要保证库存的物品列表里面
lib.cycrow.keepstock.remove: 这个脚本用来把物品从列表里面删除
lib.cycrow.keepstock.perm: 这是一个需要持续运行的脚本, 保证所有的物品都有充足的库存.

这里面只有 lib.cycrow.keepstock.add 和 lib.cycrow.keepstock.remove 这两个脚本是你会用到的. 其它两个会被其它脚本调用. 使用添加脚本来把物品添加到列表中, 你只需要添加, 脚本会自动完成剩下的工作.

第一个参数是要保证库存的物品

下一个是空间站类型, 这和你添加物品的时候是一样的.

然后是空间站的种族, 也和你添加物品时一样.

最后一个是你想要空间站里保持的数量, 比如设置为 1 就可以保证空间站里始终有 1 个物品可以购买.

使用快捷键

创建快捷键非常的简单, 你只需要在游戏中注册一下, 然后把脚本附加上去就好了. 这样就可以简单的用一个按键来运行脚本, 不必通过命令插槽或者在命令控制台中手动运行了.

在这个例子中, 我们会创建一个简单的摧毁目标的脚本, 它会摧毁当前选中的目标.

第一步: 创建脚本
第二步: 注册快捷键
第三步: 使用快捷键
第四步: 自动注册快捷键
第五步: 多语言支持
第六步: 注销快捷键

第一步: 创建脚本

首先要做的事情是创建一个脚本, 这个脚本会在快捷键被按下的时候调用. 用快捷键来调用的脚本总是作为全局脚本调用的, 由于没有在某个对象上运行, 所以 [THIS] 指针是无效的, 如果你要使用玩家当前的飞船, 就需要使用 [PLAYERSHIP] 指针了.

第一个命令是用来获得当前目标的, 这个命令是 "<RetVar/IF> get player tracking aim", 它在 "Fly Commands"(飞行命令) 菜单里.

它没有任何参数, 只有一个返回值, 我们选择一个变量(比如 "target"(目标))来接收这个返回值.

下一步我们要检查目标是否有效, 方法是检查对象 $target 是否存在. 如果玩家没有选择目标, 我们就返回 null. "exists" 命令在 "General Object Commands"(普通对象命令) 菜单中.

把第一个值设为 "Skip If", 这样如果对象存在的话就会跳过下一条语句.

然后, 把参数设置为目标对象, $target. 这样就会检查返回的对象是否存在, 如果不存在, 就会执行下面的一条语句, 在这里结束这个脚本.

在 "General Commands"(普通命令) 菜单下的 "Script Calls Commands"(脚本调用命令) 子菜单下可以找到 "return"(返回) 命令.

由于我们不需要返回什么, 所以选择 "null" 来作为它的参数.

这个命令会结束脚本, 所以之后的任何命令都不会被执行了. 如果你从另外一个脚本中调用这个脚本, 里面的 "call script" 命令的返回值就是这里你写在 "return" 后面的值, 在上面的例子里就是 "null".

现在我们可以继续剩下的部分了. 现在的脚本已经会检查玩家的目标是否有效了, 对后面的脚本来说, 目标总是存在的. 接下来我们使用摧毁目标的命令, 它在 "General Object Commands"(普通对象命令) 菜单里.

第一个参数是命令要运行的对象, 这里我们要使用的对象在 $target 变量里.

最后一个参数是爆炸相关的, 它的值是 True 或 False. 设置为 [TRUE] 表示命令执行的时候不显示爆炸效果, 目标只是消失掉. 设置为 [FALSE] 表示如果你在附近时显示爆炸效果. 不显示爆炸效果可以让脚本运行得更快, 因为不需要去计算和渲染爆炸的帧了. True 和 False 在 Constants(常量) 菜单中.

选择你喜欢的那个, 我在这里选了 TRUE

第二步: 注册快捷键

要在游戏中使用快捷键, 你需要先向游戏注册一个新的快捷键, 并指定一个按下快捷键后要执行的脚本. 这只需要一个简单的命令就完成了. 在这个的例子中, 我们创建另外一个手动运行的脚本来注册快捷键. 自动注册的方法在稍后再介绍.

首先, 我们创建一个新的脚本, 然后添加这个唯一的 "register hotkey"(注册快捷键) 命令, 这个命令在 "General Commands"(普通命令) 菜单中.

这个命令有一个返回值, 是注册的快捷键的 ID, 我们稍后再解释这个 ID, 现在用一个变量(比如 key)来保存它就好了.

下一个是显示在 "controls"(控制) 选项里的字符串, 用户在这里设置快捷键时用来提示快捷键的作用. 这里把它设置成字符串 "Destruct Targetted Object"(摧毁目标对象).

最后一个参数是要调用的脚本, 这个参数是快捷键触发时要运行的脚本. 也就是第一步的时候制作的脚本. 选择脚本的时候你会看到所有可用的脚本列表.

这个脚本就只需要这一个命令了, 当你手动运行完这个脚本后就可以使用快捷键了.

注意, 当你注册了一个快捷键后, 它会存储在你保存的游戏里面, 如果你再去注册的话, 就会同时显示几个相同的快捷键. 这样使用安装脚本(脚本名以 setup 开头的脚本)来注册快捷键就不太合适了, 那样你每次进入游戏的时候就会多产生一个快捷键项. 解决这个问题的方法稍后再详细介绍.

第三步: 使用快捷键

当你运行完注册快捷键的脚本后, 就可以设置快捷键了. 快捷键需要在游戏里的 control(控制) 选项里进行设置.

所有脚本添加的快捷键都在 "Interface"(接口) 标签页底部的 "Extensions"(扩展) 区里面.

然后需要找到你添加的那个, 显示的名字就是你在 register(注册快捷键) 命令中使用的字符串.

设置快捷键的方法和游戏中其它的控制选项一样. 设置好之后你只需要在战斗中按下这个键就好了. 如果你选中了一个目标, 它就会被摧毁, 否则什么都不会发生.

第四步: 自动注册快捷键

我们目前系统的用户友好度还远远不够, 它要求用户在每次新开的存档中都手动运行一次注册脚本. 使用安装脚本会更好一些, 这些脚本会在载入游戏的时候自动运行. 这样的问题在于, 每次你载入游戏就会增加一个重复的快捷键项. 要避免这种现象, 你需要检查快捷键是否已经被注册过了.

要实现这些, 我们需要在存档中存储一个键值(key). 然后, 如果这个键值存在, 就不必再注册快捷键了. 这个可以通过全局变量来实现. 全局变量和其它变量不同, 它可以让你把一个值或对象和一个字符串关联起来, 并存储在游戏存档中. 这些保存的值可以在任何时候, 任何脚本中进行访问.

所以, 我们第一步需要创建一个安装脚本, 这很简单, 和创建普通脚本差不多, 唯一的区别是文件名, 如果脚本的名字是以 "setup." 开头的, 它就是安装脚本. 比如 "setup.register.hotkey".

首先, 我们需要通过我们的变量来检查快捷键是否存在. 这需要使用 "General Object Commands"(普通对象变量) 中的 "get global varible"(获取全局变量) 命令.

返回值是全局变量中当前存储的值, 这里设置为 key 变量.

下一个参数是变量名字, 这是一个字符串, 你可以使用任意数量的全局变量. 按照惯例, 这个名字使用脚本名字做为前缀, 比如: "destruct.key".

现在, 你需要检查 $key 变量是否有效, 如果它没有被赋值过, 就会返回 "null". 你可以使用条件表达式, if 语句来检查 key 变量. 如果它无效, 你就可以使用 "register" 命令来注册快捷键了.

现在, 添加和之前注册快捷键一样的命令, 记得把注册快捷键的返回值存储起来.

现在, 把 $key 的值存储在全局变量中, 到下次运行的时候就能检测到它被用过了. 为此, 我们需要使用 "General Commands"(普通变量) 中的 "set global varible" 命令.

第一个参数是变量名, 这应该是和你在 "get global varible" 中使用的一样, "destruct.key".

最后一个参数是你要赋的值, 也就是你使用 "get global varible" 命令时的返回值. 因此, 我们把 $key 变量中存储的值传递给它.

最终, 我们要关闭 if 语句来结束这个脚本. 这样, 下次你加载游戏的时候, 这个脚本就会运行, 完成快捷键注册. 这个变量在注销快捷键的时候也需要使用.

第五步: 多语言支持

这个脚本现在还不够完美, 控制(controls)菜单中显示的名字还需要被修正, 如果要在多语言下使用这个脚本, 这个名字修改起来很不方便. 要解决这个问题, 我们可以创建一个语言文件来提供控制菜单中显示的字符串. 然后, 我们使用从语言文件读取的字符串文本来代替写死的字符串.

首先要做的是在开始的地方插入 "load text" 命令, 并填入要加载的 TEXT_ID. 如何创建语言文件可查看之前的介绍.

然后, 在注册快捷键之前, 我们需要从文件中取得对应的文本, 使用 "read text" 命令并设置对应的 PAGE_ID 和 TEXT_ID, 并把返回值保存在一个变量里面.

最后, 把注册快捷键时使用的字符串改为包含了语言文件文本的变量 $text.

快捷键注册完成之后再对文本做修改是不会起效的, 它只在你第一次注册快捷键的时候有用. 如果你要改变这个名字, 你需要先注销, 然后重新注册.

第六步: 注销快捷键

要注销快捷键, 你需要知道快捷键的 ID, 就是你存储在全局变量中的那个. 所以, 首先要做的就是从全局变量中取得快捷键 ID, 不过这次需要确认它的值是 true, 用 "if" 来代替 "if not"

下一步是添加 "unregister hotkey" 命令, 这个命令在 "General Commands"(普通命令") 菜单中.

唯一的参数是快捷键 ID, 也就是存储在 $key 变量中的值.

现在, 你需要取消全局变量的值, 因为快捷键 ID 已经无效了. 使用 "set global varible" 命令, 但是把值设置成 "null", 这会取消变量的值.

现在, 运行这个脚本就会从列表中删除这个快捷键, 之后你就可以再次注册这个快捷键了. 当脚本不再需要时, 也需要用它来做清理工作.

AL插件

什么是 AL 插件
创建 AL 插件
第一步: 设置参数
第二步: 初始化脚本
第三步: AL 插件的设置数组
第四步: 初始化(init)事件
第五步: 开始(start)事件
第六步: 结束(stop)事件
第七步: 是否启用(isenabled)事件
第八步: 定时器(timer)事件
第九步: 注册 AL 插件

什么是 AL 插件

AL 插件, 也就是虚拟生命插件(Artifical Life Plugins), 是在 X2 的 1.4 版本补丁中加入的. 用于向宇宙中添加更多有生命的东西. 但是, 在 X3 中, AL 插件主要用于脚本中, 所以默认没有配置. AL 配置在 gameplay(游戏) 选项菜单中, 但是只有在游戏中启用了脚本编辑器才会显示. AL 插件基本上还是一个脚本, 只是可以让用户自由的启用和禁用. AL 插件是基于事件系统的, 所以你需要创建 "Event"(事件) 脚本来处理每个事件.

创建 AL 插件

首先需要的是创建事件回调脚本, 也就是 AL 事件触发的时候被调用的脚本. 创建的方法和普通脚本一样, 它需要 2 个参数. 第一个是 AL 插件 ID, 它是一个字符串; 第二个是调用的事件, 它也是一个字符串.

当 AL 插件被注册后, 游戏引擎会给插件分配一个唯一的身份标识, 这是一个字符串 ID, 你可以通过它来设置属性和控制插件.

第一步: 设置参数

如前所述, 事件脚本需要 2 个参数, 把他们都设置成 "var/string" 类型.

第一个是插件标识(Plugin ID), 第二个是事件字符串.

第二步: 初始化脚本

游戏引擎实际上并不保存 AL 插件的状态, 比如它是打开还是关闭. 你必需自己存储这些信息. 你可以创建一个数组来存储这些插件的设置, 比如, 插件的版本, 是否启用, 以及其它任何你需要的东西. 版本可以用来检查是否有更新, 并根据需要进行修改.

设置信息只需要创建一次, 所以你需要检查全局变量来判断是否已经创建过了. 对于全局变量的名字, 你可以使用插件标识(plugin id), 它是唯一的, 并且在脚本中一直有效.

我这里做了点处理, 定义了一些变量来方便阅读, 比如, 把数组的每一个位置赋值给一个变量名, 然后就可以用名字来代替数字了.

设置版本号为 0, 启用标志为 1, 这意味着版本号的配置会存储在配置数组的第 0 个位置, 启用标志存储在第 1 个位置. 如果你还有其它配置, 你可以把它们设置为 2, 3, 4, 等等. 这些都是它们在数组中的位置.

第三步: AL 插件的设置数组

现在, 我们需要为 AL 插件创建设置数组. 首先是要检查它是否创建过了, 如果没有就创建一个.

这里使用 AL 插件的字符串 ID 作为全局变量, 也就是 $al.PluginID 变量. 如果你创建过数组了, 它会被返回, 否则, 我们还需要创建它. if 语句用来检测它是否需要创建.

首先, 你需要按照你需求的大小创建一个数组, 这里我们需要 2 个, 版本号和是否启用. 然后, 我们把配置信息放到数组中, 使用之前创建的变量来代替数字. 你可以把启用标志设置为 [TRUE] 或者 [FALSE], 这要看你希望在脚本一开始的时候 AL 插件是启用的还是禁用的. 最后, 你需要用 "set global varible" 命令把数组保存到全局变量中.

第四步: 初始化(init)事件

现在, 我们的脚本已经设置好了, 可以检测当前调用的事件了. 它存储在事件字符串, 第二个参数中. 简单的 if 语句就可以判断当前是什么事件. 我们首先要处理的事件是 "init"(初始化) 和 "reinit"(重新初始化) 事件. "init" 事件在插件第一次创建的时候产生; "reinit" 事件在插件被再次调用的时候产生, 比如你重置脚本缓存的时候. 这里是我们要设置 AL 插件的配置, 描述, 和定时器的地方.

第 13 行的 if 语句检查事件是否为 "init" 和 "reinit" 字符串. 所以, 它是被这两个不同的事件共同使用的;

第 16 行设置插件的描述, 它是显示在 AL 设置菜单中的文本. 这里, 我们使用标准的语言文件来获取文本, 并把它设置到对应 ID 的插件上. 对于所有的 AL 命令, 你都需要插件 ID 字符串作为命令的参数.

第 17 行是时间间隔, 它设置了 AL 插件的定时器. 定时器让你的脚本每间隔一定的时间可以被唤醒起来做点事情. 比如, 把它设置为 10 秒的话, 每隔 10 秒就会让它起来做点什么. 如果你只想启用或禁用选项是不需要使用定时器的.

AL 引擎的命令都在 "General Command"(普通命令) 菜单里.

第五步: 开始(start)事件

当用户启用 AL 插件(比如在菜单你把它设置为 "Yes")时会触发 start(开始) 事件, 这时, 我们需要改变设置数组里面的启用标志为真(true).

你也可以在这里做其它启动插件时需要的事情, 比如, 启用时必须的一些初始化工作等. 这和 init 事件不同, init 事件是在插件被创建的时候触发, start 事件是在插件每次被设置为 yes 的时候触发

第六步: 结束(stop)事件

和 start 事件类似, 不过这个是在插件被禁用的时候触发, 比如被设置为 "no". 这里你也只需要把启用标志设置为 false 就可以了. 这里也是做一些必须的清理工作的好地方. 比如, 如果插件被用来创建了空间站或飞船, stop 事件可以用来删除这些空间站和飞船.

第 025 行调用了一个脚本来删除宇宙中的赏金(bounties), 这是在赏金猎人工会(bounty Hunters Guild)脚本中使用的.

第七步: 是否启用(isenabled)事件

isenabled(是否启用) 事件用来检查 AL 插件的状态. 它在你查看 AL 设置的时候使用, 游戏用它来判断是显示 "enabled" 还是 "disabled". 这个事件要求返回 [TRUE] 或 [FALSE]. 这也是我们需要使用启用标志的原因之一, 有了它我们才能返回正确的插件状态.

这个事件必须返回一个值, 这里简单的返回启用标志.

第八步: 定时器(timer)事件

timer 事件由定时器每隔一定的时间触发一次, 所以, 如果你设置定时器为 10 秒, 这个事件就会每 10 秒触发一次. 比较好的做法是在定时器事件里调用一个单独的定时器脚本, 因为当你注册 AL 插件的时候, 主脚本就已经被缓存了, 这样在测试的时候你做的任何修改都不会马上生效, 而调用单独的脚本是不会被缓存的, 每次调用都会把你的修改用上, 对测试来说就非常有用了. 而且这样还可以让你的脚本文件更加整洁, 而不是一个文件里什么都有.

还有一点, 要检查下启用标志, 确认只有在 AL 插件被启用的情况下才去调用脚本.

我把设置数组和插件 ID 也传递过去了, 这不是必须的, 但是你可能想在定时器脚本中用它们来检查些什么.

这就是所有的事件脚本了, 定时器脚本就是一个标准的脚本, 它的内容要看你想要插件做什么了.

第九步: 注册 AL 插件

最后一步是把 AL 插件注册到游戏引擎中去, 这样事件脚本才会被调用. 这实现起来非常简单, 我们只需要告诉游戏我们的事件脚本是什么, 剩下的事情就由游戏引擎和事件脚本来完成了.

这个最好使用一个 al.plugin 文件来完成, 所有以 al.plugin 开头的文件会在游戏启动的时候自动加载, 就像安装脚本一样.

你只需要使用 "General Commands"(普通命令) 中的 "register script" 命令就行了. 然后, 把参数设置为之前创建的那个事件脚本.

注册的脚本不会存储在游戏存档里面, 你需要每次载入游戏的时候都注册一次. 这也是我们使用 al.plugin 文件的原因.

字符串使用

这部分教程是创建语言文件的后续, 它主要告诉你如何使用参数来格式化你的字符串, 让字符串中可以包含你脚本里的变量. 之前的指南在这里.

可以使用的命令主要有 2 个, 也就是 "sprintf" 命令, 可以让你用变量来格式化你的消息字符串. 它们在 "General Commands"(普通命令) 菜单中.

第一个, "sprintf: fmt =" 命令使用的是一个格式化字符串, 它包含了你想要的字符串的格式; 第二个, "sprintf: pageid=" 命令类似, 不过没有格式化字符串, 它直接从语言文件中来获取这个格式化字符串.

格式化字符串

使用第一个命令, "sprintf: fmt =", 可以用变量来格式化字符串. 第一个参数, <Var/String> 是字符串的格式, 它可以是任何字符串, 这个字符串格式化好后会作为返回值返回给 <RetVar>.

下面是一个简单的例子, 虽然它没有什么意义.

这是格式化字符串 "This is a String" 的简单尝试. 由于里面没有特殊字符, 也就没有什么要格式化的, 因此, $text 变量现在就包含 "This is a String" 字符串了.

现在, 我们来加入一些特殊字符, 其中最有用的是 "%s", 它将会被后面的第一个参数替换掉. 正如你看到的一样, 格式化字符串后面有 5 个额外的参数, 每一个变量可以替换掉格式化字符串中的一个 "%s". 第一个 "%s" 用第一个参数来替换, 以此类推.

第二个例子的格式化字符串包含了一个 "%s". 因此, 它会被替换成 $string 变量中的内容. 因此, $text 现在等于 "String: This is a String" 了. 对象也可以这样使用, 比如玩家的飞船.

这样会把你当前飞船的名字插入到字符串中, 比如, $text 可能是: "Your Ship: Your Split Mamba".

有多个变量时, 只需要简单的增加格式化字符串里的 "%s" 就可以了. 每一个命令里最多可以达到 5 个.

这里我们使用了 2 个变量, 它会显示你的飞船名字和你的名字, 即飞行员的名字.

从语言文件中读取格式化字符串

你已经学会使用格式化字符串了, 你可以把这个字符串放在语言文件中. 在上面的例子中, 你可以把 "Ship: %s, Pilot: %s" 字符串放在语言文件中你选择的页面里.

<?xml version="1.0" encoding="UTF-8" ?>
<language id="44">
  <page id="1000">
    <t id="1">Ship %s, Pilot: %s</t>
  </page>
</language>

在语言文件中添加上面的内容, 然后就可以在脚本中使用它了. 你应该使用另外一个 sprintf 命令, "sprintf: page id=" 命令. 第一个参数是你使用的 PAGE_ID, 这个例子中为 1000, 第二个参数是 TEXT_ID, 即这里的 1.

剩下的 5 个参数和之前的命令一样, 被用来替换字符串里的 "%s".

它的返回值和之前的一样, 但是格式化字符串将从语言文件中读取. 这样做的优点在于你可以将它格式化成各种不同的语言了, 还可以在不修改脚本的情况下改变字符串的内容.

交互问卷

问卷 (Incomming questions) 用来获取玩家的输入, 它们像普通的消息一样工作, 但是包含了一些选项让玩家选择, 就像 BBS 一样. 问卷和普通消息的主要区别在于文本的格式和回调脚本. 回调脚本是用来响应消息里面的问题的.

问卷可以用来创建菜单系统. 菜单系统可以用来减少脚本使用的命令插槽数, 也可以用来创建配置菜单.

对于这方面的例子, 你可以查看我的 "Xenon Migration" 脚本, 它使用问卷(incomming questions)作为配置菜单, 还有 "Capital Ship Crews" 使用了这种方法来减少命令插槽, 它把所有的动作都通过菜单而不是命令来调用.

实例下载:

实例一: 基本问题和回调

1. 创建问题的语言文件

首先, 我们要看看语言文件的格式, 它是怎么显示给用户的. 这是通过标准的语言文件来实现的, 相关信息参考这里.

然后, 你需要在语言文件中添加问题. 每个问题都需要使用 [select][/select] 标签来创建.

  <t id="1">
    This is out test question\n\n
    [select value="1"]Answer 1[/select]\n
    [select value="2"]Answer 2[/select]\n
  </t>

这个例子里的问题有 2 个答案, 从标记的地方分开看, 每个答案都是一个单独的 [select] 项.

    [select value="1"]Answer 1[/select]

"value" 是必须的, 这样回调脚本才能知道选择的是哪一个答案. 每一个答案都需要有一个不同的 value 字符串值.

在两个标记之间的字符串, "Answer 1", 是显示在问题框里面的.

还有一点, 答案必须分隔在不同的行里面, 你不能在同一行里面有 2 个答案, 所以在答案之间必须有 '\n' 才行. 你可以在答案之间添加其他的内容, 所以, 你也可以这样:

  <t id="1">
    This is out test question\n\n
    [select value="1"]Answer 1[/select]\n
    Some text between the answer\n
    [select value="2"]Answer 2[/select]\n
  </t>

2. 在脚本中使用问题

现在, 你已经有一个格式化好的语言文件了. 你可以使用和其它字符串一样的方法来使用它. 语言文件需要被载入, 这通常是通过安装脚本来完成的. 然后, 使用 "read text page" 或者 "sprintf" 函数来读取相应的文本.

问卷和消息唯一不同的是用来显示它们的命令. 问卷使用 "send incomming question" 命令, 它在 "Audio Commands"(音频命令) 菜单中.

第一个参数是要显示的文本, 包括其中的答案部分, 如果没有定义答案, 它的显示就和普通的静态文本一样了.

第二个参数非常重要, 它使得问卷不同于普通的消息, 它需要设置成回调的脚本. 回调脚本是你需要创建的另外一个脚本, 当用户选择了一个答案后, 回调脚本就会被调用, 这个脚本控制着答案的行为.

3. 显示问卷

现在, 你已经创建好了显示问卷的脚本了, 你可以运行它来看看是什么样子.

一旦你运行这个脚本, 你就会收到一条新消息(incomming message), 你可以查看它, 它可以让你选择想要的答案.

正如你看到的, 这里有 2 个答案, 就是你在语言文件中定义的那两个 [select]. 出现在 [select] 和 [/select] 之间的字符串会显示在答案框里面.

4. 回调脚本

最后, 你还需要创建一个回调脚本, 回调脚本是用户选择答案后调用的脚本. 所以, 当你选择了 "Answer 1" 后, 被定义成回调脚本的脚本将会运行.

所有的答案调用的都是同一个脚本, 因此, 你需要一种方法来判断用户选择的是哪一个答案. 这就是为什么要在 [select] 里定义一个 value 了. 在回调脚本里, 你需要定义一个参数, 这个参数的值将会是你在 [select] 的 value 中填写的字符串.

把第一个参数设置为 "answer" 意味着 $answer 变量会包含问卷的答案. 如果用户选择了 "Answer 1", $answer 将会是 "1", 如果选择了 "Answer 2", $answer 将会是 "2"

使用它的最好方法就是为每一个答案使用一个 if 语句.

然后你还需要做的就是把你的代码放到 if 语句块中了. 用这些代码来实现你想要每个答案完成的事情. 作为例子, 这里只是简单的在 logbook(飞行日志) 中显示消息.

你可能注意到了, 虽然 $answer 是一个字符串, 这个例子里面却把它当作整数来比较了, 这是因为问卷系统会自动转换变量的类型为正确的类型. 所以, 由于你已经使用整数作为答案的 value 了, $answer 变量会转换成整数, 你应该用整数来和它进行比较, 而不是字符串. 如果你使用了类似 "[select value="answer1"]Answer 1[/select]" 这样的 value, 你就应该把它和字符串进行比较了.

if $answer == 'answer1'

附录: 命令列表

X3 命令列表 (v2.0.02)

Notes(备注)
General Commands(普通命令)
Audio Commands (音频命令)
Logbook Commands (飞行日志命令)
Fly Commands (飞行命令)
Trade Commands (贸易命令)
General Object Commands(普通对象命令)
- General Object Commands - Weapon Information(普通对象命令 - 武器信息)
Universe / Sector Commands(宇宙和星区命令)

备注:

<RetVar> 是函数的返回值
<RefObj> 是对象引用, 实现特定函数的.
在标记 <..>中的是函数参数.
函数之前加 @ 表示它是可以中断的.
这个版本是在 X2 的德文论坛版上更新的.

[adie: 原文的备注在命令列表后面, 这里被提到前面来了. 另, 原文目录中并没有 "General Commands - Arrays" (普通命令 - 数组) 这项, 正文中出现也因为排版问题被划到 "General Commands - Script Calls" 下面了, 译者整理时提出来并在目录中增加了一条. ]

General Commands(普通命令)

<RetVar/IF><Expression>
inc <RetVar> =
dec <RetVar> =
@<RetVar/IF>wait <Var/Number> ms
@<RetVar/IF>wait randomly for <Var/Number> to <Var/Number>ms
<RetVar> = random value from 0 to <Var/Number> -1
<RetVar> = script engine version
<RetVar> = random value from <Var/Number> to <Var/Number> -1
*<Comment>
<RetVar> = = get script priority
<RefObj> -> start task <Var/Number> with script <script name> and prio <Var/Number>: arg1=<value> arg2=<value> arg3=<value> arg4=<value> arg5=<value>
<RefObj> -> interrupt task <Var/Number> with script <script name> and prio <Var/Number>: arg1=<value> arg2=<value> arg3=<value> arg4=<value>
<RefObj> interrupt with script <Script Name> and prio <Var/Number>: arg1=<Value> arg2=<Value> arg3=<Value> arg4=<Value>
set script priority to <Var/Number>
<RetVar/IF> is script with prio <Var/Number> on stack
<RetVar/IF> get task ID
<RetVar/IF> get task PID
<RefObj> interrupt with script <Script Name> and prio <Var/Number>
<RefObj> connect ship command/signal <Object Command/Signal> to script <Script Name> with prio <Var/Number>
<RefObj> set ship command/signal <Object Command/Signal> to global default behaviour
<RefObj> ignore ship command/signal <Object Command/Signal>
enable signal/interrupt handling: <Var/Number>
<RetVar/IF> is signal/interrupt handling on
global script map: set: key=<Object Command/Signal>,class=<Var/Class>,race=<Var/Race>,script=<Script Name>,prio=<Var/Number>
global script map: remove: key=<Object Command/Signal>,class=<Var/Class>,race=<Var/Race>
global script map: ignore: key=<Object Command/Signal>,class=<Var/Class>,race=<Var/Race>
set script command upgrade: command=<Object Command/Signal> upgrade=<Var/Ware>
<RetVar> = get script command upgrade: command=<Object Command/Signal>
set script command: <Object Command/Signal>
<RetVar/IF> get script command
set script command target: <Value>
<RetVar/IF> get script command target
<RetVar> = datatyp[<Value>]
<RetVar/IF> is datatyp[<Value>] == <Var/Script Data Type>
<RetVar> = read text: page=<Var/Number> id=<Var/Number>
<RetVar> = sprintf: fmt=<Var/String>,<Value>,<Value>,<Value>,<Value>,<Value>
<RetVar> = sprintf: pageid=<Var/Number> textid=<Var/Number>,<Value>,<Value>,<Value>,<Value>,<Value>
load text: id=<Var/Number>
<RetVar> = state of news article: page=<Var/Number> id=<Var/Number>
set state of news article: page=<Var/Number> id=<Var/Number> to <Var/Number>
<RetVar/IF> system date is month=<Var/Number>,day=<Var/Number>
<RetVar> = playing time
infinite loop detection enabled=<Var/Number>
set script command upgrade: command=<Object Command/Signal> upgrade=<Var/Ware> script=<Script Name>
<RefObj> set local variable: name=<Var/String> value=<Value>
<RetVar/IF><RefObj> get local variable: name=<Var/String>
set global variable: name=<Var/String> value=<Value>
<RetVar/IF> get global variable: name=<Var/String>
al engine: register script =<Script Name>
al engine: unregister script <Script Name>
al engine: set plugin <Var/String> description to <Var/String>
al engine: set plugin <Var/String> timer interval to <Var/Number> s
<RetVar> = get script version
<RetVar> = get script name
<RetVar/IF> = is plot <Var/Number> state flag <Var/Number>
<RetVar> = get random name: race=<Var/Race>
<RetVar> = get Khaak aggression level
set Khaak aggression level to <Var/Number>
<RetVar/IF> <RefObj>is script <Script Name> on stack of task=<Var/Number>
<RetVar/IF> <RefObj>is task<Var/Number> in use
register quest script<Script Name> instance multiple=<Var/Number>
set quest state with message: quest=<Var/Quest> state=<Var/Number> msg=<Var/String>
set quest/event<Var/Quest> timer to <Var/Number>ms
set quest<Var/Quest> timeout to <Var/Number>
<RefObj> add event listener: quest/event=<Var/Quest> objevent=<Var/Number> script=<Script Name>
<RefObj> remove event listener: quest/event=<Var/Quest>
<RetVar/IF> display news article: page=<Var/Number> newsid=<Var/Number> occurrences=<Var/Number> maxoffertime=<Var/Number> maxtime=<Var/Number> placeholder: race1=<Var/Number> race1=<Var/Number> customarray=<Var/Array>
change event news availabilty: <Var/Number> race=<Var/Race> sector=<Var/Sector> jumps=<Var/Number>
<RetVar> = register hotkey <Var/String> to call script <Script Name>
unregister hotkey <Var/Number>
register god event: script= <Script Name>mask=<Var/Number>
abort god event: <Var/Quest>
finish god event: <Var/Quest>
<RefObj> connect wing command/signal <Object Command/Signal> to script <Script Name> with prio <Var/Number>
<RetVar/IF> is new script version available

General Commands - Flow Control(普通命令 - 流程控制)

end conditional
else
continue
break
goto label <Label>
define label <Label>
gosub <Label>
endsub

General Commands - Script Calls(普通命令 - 脚本调用)

return <Value>

General Commands - Arrays(普通命令 - 数组)

<RetVar> = array alloc: size=<Var/Number>
<RetVar/IF> <Var/Array>[<Var/Number>]
<Var/Array>[<Var/Number>] = <Value>
<RetVar/IF> = size of array <Var/Array>
<RetVar> = clone array <Var/Array>: index <Var/Number>... <Var/Number>
copy array <Var/Array> index <Var/Number> ... <Var/Number> into array <Var/Array> at index <Var/Number>
insert <Value> into array <Var/Array> at index <Var/Number>
append <Value> to array <Var/Array>
remove element from array <Var/Array> at index <Var/Number>
resize array <Var/Array> to <Var/Number>
<RetVar/IF> <Var/Array>[<Var/Number>][<Var/Number>]
<Var/Array>[<Var/Number>][<Var/Number>] = <Value>
<RetVar> = get index of <Value> in array<Var/Array> offset =<Var/Number> +1
<Var/Array>[<Var/Number>] = <Var/Array>[<Var/Number>]

General Commands - Strings(普通命令 - 字符串)

<RetVar/IF> = get length of string <Var/String>
<RetVar> = find position of pattern <Var/String> in <Var/String>
<RetVar> = get substring of <Var/String> offset =<Var/Number> length=<Var/Number>
<RetVar> = string <Var/String> to integer
<RetVar> = substitute in string <Var/String>: pattern <Var/String> with <Var/String>
<RetVar> = format seconds <Var/String> to Zura time string

General Commands - Math(普通命令 - 数学)

<RetVar> = = fixed sin <Var/Number>
<RetVar> = = fixed cos <Var/Number>
<RetVar> = square root of <Var/Number>

Audio Commands (音频命令)

play sample <Var/Number>
play sample: incoming transmission <Var/Number>, from object <Value>
<RefObj> send audio message <Var/Number> to player
send incoming message <Var/String> to player: display it=<Var/Number>
send incoming question <Var/String> to player: callback=<Script Name>
<RetVar/IF/START> speak text: page=<Var/Number> id=<Var/Number> priority=<Var/Number>
<RefObj> send incoming message: text = <Var/Sting> temporary = <Var/Number>

Logbook Commands (飞行日志命令)

write to player logbook <Value>
write to player logbook: printf: fmt=<Var/String>,<Value>,<Value>,<Value>,<Value>,<Value>
write to player logbook: printf: pageid=<Var/Number> textid=<Var/Number>,<Value>,<Value>,<Value>,<Value>,<Value>
<RefObj> write to logbook <Value>
write to log file #<Var/Number> append=<Var/Number> value=<Value>
write to log file #<Var/Number> append=<Var/Number> printf: fmt=<Var/String>, <Value>, <Value>, <Value>, <Value>, <Value>
write to log file #<Var/Number> append=<Var/Number> printf: pageid=<Var/Number> textid=<Var/Number>, <Value>, <Value>, <Value>, <Value>, <Value>

Fly Commands (飞行命令)

@<RetVar/IF><RefObj> fly to home base
@<RetVar/IF><RefObj> fly to station <Var/Station>
@<RetVar/IF><RefObj> fly to sector <Var/Sector>
<RetVar/IF><RefObj> find nearest enemy ship: max.dist=<Var/Number>
<RetVar/IF><RefObj> find nearest enemy station: max.dist=<Var/Number>
<RetVar/IF><RefObj> fire lasers on target <Value> using turret <Var/Number>
@<RetVar/IF><RefObj> turn turret <Var/Number> to target <Var/Ship/Station>: timeout=<Var/Number> ms
@<RetVar/IF><RefObj> attack run on target <Value>: timeout=<Var/Number> ms
@<RetVar/IF><RefObj> defensive move: type=<Var/Number>,intensity=<Var/Number>,timeout=<Var/Number> ms, avoid object=<Value>
@<RetVar/IF><RefObj> move to ware object <Value> for collecting: timeout=<Var/Number> ms
<RetVar/IF><RefObj> catch ware object <Value>
@<RetVar/IF><RefObj> move around <Var/Number> ms
@<RetVar/IF><RefObj> escort ship <Var/Ship>
@<RetVar/IF><RefObj> escort ship <Var/Ship>: timeout=<Var/Number> ms
<RefObj> set formation <Var/Number>
<RefObj> add to formation with leader <Var/Ship>
<RefObj> remove from any formation
<RetVar/IF><RefObj> get formation leader
<RetVar> = <RefObj> get formation follower ships
START <RefObj> command <Object Command>: arg1=<Value>,arg2=<Value>,arg3=<Value>,arg4=<Value>
<RefObj> send signal <Object Signal>: arg1=<Value>,arg2=<Value>,arg3=<Value>,arg4=<Value>
@<RetVar/IF><RefObj> follow object <Var/Ship> with precision <Var/Number> m
@<RetVar/IF><RefObj> follow <Var/Ship> with precision <Var/Number> m: timeout=<Var/Number> ms
<RefObj> set follow mode <Var/Number>
<RetVar/IF><RefObj> get follow mode
<RefObj> set destination to <Value>
<RetVar/IF><RefObj> get destination
<RefObj> set attack target to <Value>
<RetVar/IF><RefObj> get attack target
@<RetVar/IF><RefObj> move to position x=<Var/Number> y=<Var/Number> z=<Var/Number> with precision <Var/Number> m
<RefObj> set command: <Object Command>
<RetVar/IF><RefObj> get command
<RefObj> set command target: <Value>
<RetVar/IF><RefObj> get command target
<RefObj> set command target2: <Value>
<RetVar/IF><RefObj> get command target2
<RetVar> = <RefObj> select new formation leader by: ship class=<Var/Number> strength=<Var/Number> min.speed=<Var/Number>
<RetVar/IF><RefObj> has formation ships
<RefObj> give formation leadership to <Var/Ship>
<RefObj> set pilot fightskill to <Var/Number>
<RetVar> = <RefObj> get pilot fightskill
<RetVar/IF> get player tracking aim
<RetVar/IF><RefObj> is <Var/Ship/Station> in firing range of turret <Var/Number>
<RetVar> = <RefObj> find enemy in firing range of turret <Var/Number>
<RefObj> set command: <Object Command> target=<Value> target2=<Value> par1=<Value> par2=<Value>
<RetVar/IF><RefObj> fire missile <Var/Ware> on <Value>
<RetVar/IF><RefObj> get current missile
<RetVar/IF><RefObj> find best missile for target <Value>
<RetVar> = best missile type for target <Value>
<RetVar/IF><RefObj> launch <Var/Number> fight drones: protect me or attacktarget=<Value>
<RetVar/IF><RefObj> is missile <Var/Ware> ready to fire
<RetVar/IF><RefObj> should a missile be fired
<RetVar> = <RefObj> get fire missile probability
<RetVar> = <RefObj>get fire missile time difference in seconds
<RefObj> set fire missile probability to <Var/Number>
<RefObj> set fire missile time difference to <Var/Number> s
<RetVar/IF><RefObj> fits laser <Var/Ware> into turret <Var/Number>
<RetVar> = <RefObj> get max. number of lasers in turret <Var/Number>
<RetVar> = <RefObj> get laser type in turret <Var/Number> at slot <Var/Number>
<RetVar> = <RefObj> get number of turrets
<RetVar> = get range of missile type <Var/Ware>
<RetVar> = <RefObj> find nearest missile aiming to me
<RetVar/IF><RefObj> can missile <Var/Ware> be installed
<RetVar/IF><RefObj> decouple ships
<RetVar/IF><RefObj> is decoupled ships leader
<RetVar/IF><RefObj> get current galaxy flight timestep in ms
<RetVar/IF><RefObj> is landing
<RetVar/IF><RefObj> is starting
@<RetVar/IF><RefObj> move to position continue: x=<Var/Number> y=<Var/Number> z=<Var/Number> with precision <Var/Number> m
<RetVar/IF><RefObj> move to debris/asteroid <Value> and turn turret <Var/Number> to target: timeout=<Var/Number
<RetVar/IF><RefObj> use jump drive: target=<Value>
<RetVar/IF><RefObj> needed jump drive energy for jump to sector <Var/Sector>
<RetVar/IF><RefObj> check, select and fire missile on <Value>
<RetVar/IF><RefObj> add big ship <Var/Ship>
<RetVar/IF><RefObj> has a free big ship dock port: ship subtype = <Value>
<RetVar/IF><RefObj> can be controlled by race logic
<RefObj> set race logic control enabled to <Var/Number>
<RetVar/IF><RefObj> can execute StartAction
<RefObj> set StartAction enabled to <Var/Number>
<RefObj> set as player wingman: <Var/Number>
<RetVar/IF><RefObj> is player wingman
set player tracking aim to <RefObj>
<RetVar> = <RefObj> get formation
<RetVar/IF><RefObj> get current action
<RetVar> = <RefObj> get array of missiles aiming at me
<RetVar/IF><RefObj> turret <Var/Number> can use laser <Var/Ware>
<RefObj> set pirate cover state to <Var/Number>
<RetVar/IF><RefObj> scan potential pirate <Var/Ship> for illegal wares
@<RetVar/IF><RefObj> attack run on target <Value> : timeout= <Var/Number> ms speedlimit=<Var/Nmber>
<RetVar/IF><RefObj> is target visible <Var/Ship/Station>
<RetVar> = <RefObj> get scanner range
<RefObj> select and switch lasers for target <Var/Ship/Station> in turret <Var/Number> : scan for friends <Var/Number>
<RetVar/IF><RefObj> get homesector
<RefObj> set homesector to <Var/Sector>
<RetVar/IF><RefObj> get job leader
<RetVar> = <RefObj> get job idle rate
<RetVar> = <RefObj> get flight time
<RefObj> reset flight time
<RetVar> = <RefObj> get job jump range
<RetVar/IF><RefObj> wait idle rate minimum: <Var/Number> ms
<RetVar> = <RefObj> fire laser of turret <Var/Number> ahead
<RefObj> auto sync patrol sector with environment: <Var/Number>
<RefObj> add to patrol group for sector: <Var/Sector>
<RefObj> remove from patrol group for sector: <Var/Sector>
<RefObj> remove all patrol group references
<RefObj> set relations from notoriety: include player as target and race > teladi as owner =<Var/Number>
<RetVar/IF><RefObj> get job id

Trade Commands (贸易命令)

<RetVar/IF> get player money
add money to player: <Var/Number>
<RetVar/IF><RefObj> add<Var/Number> units of <Var/Ware>
<RetVar/IF><RefObj> install <Var/Number> units of <Var/Ware>
<RetVar> = get volume of ware <Var/Ware>
<RetVar> = get transport class of ware <Var/Ware>
<RetVar/IF> find station: product <Var/Ware> with best price: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station: product <Var/Ware> with min. jumps: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station: resource <Var/Ware> with best price: min.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station: resource <Var/Ware> with min. jumps: min.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station sells: resource <Var/Ware> with best price: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station sells: resource <Var/Ware> with min. jumps: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar> = get average price of ware <Var/Ware>
<RetVar> = get max price of ware <Var/Ware>
<RetVar> = get min price of ware <Var/Ware>
<RetVar> = get max price of ware <Var/Ware> as secondary resourcer
<RetVar> = get min price of ware <Var/Ware> as secondary resourcer
<RetVar/IF> is ware <Var/Ware> illegal in <Var/Race> sectors
<RetVar> = get maintype of ware <Var/Ware>
<RetVar> = get subtype of ware <Var/Ware>
<RetVar> = get ware from maintype <Var/Number> and subtype <Var/Number>
<RetVar> = get number of subtypes of maintype <Var/Number>
<RetVar> = <RefObj> get maintype
<RetVar> = <RefObj> get subtype
<RetVar/IF><RefObj> find station: product <Var/Ware> with best price: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF><RefObj> find station: product <Var/Ware> with min. jumps: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF><RefObj> find station: resource <Var/Ware> with best price: min.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF><RefObj> find station: resource <Var/Ware> with min. jumps: min.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF><RefObj> find station sells: resource <Var/Ware> with best price: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF><RefObj> find station sells: resource <Var/Ware> with min. jumps: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station: product <Var/Ware> with best price depend on jumps: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station: resource <Var/Ware> with best price depend on jumps: min price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar/IF> find station sells: resource <Var/Ware> with best price depend on jumps: max.price=<Var/Number>, amount=<Var/Number>, max.jumps=<Var/Number>, startsector=<Var/Sector>, trader=<Var/Ship/Station>
<RetVar> = get relvalue of <Var/Ware>

Trade Commands - Ships(贸易命令 - 飞船)

<RetVar/IF><RefObj> buy<Var/Number> units of <Var/Ware>
<RetVar/IF><RefObj> buy<Var/Number> units of <Var/Ware> to a max. price of <Var/Number> Cr
<RetVar/IF><RefObj> sell <Var/Number> units of <Var/Ware>
<RetVar/IF><RefObj> load <Var/Number> units of <Var/Ware>
<RetVar/IF><RefObj> unload <Var/Number> units of <Var/Ware>
<RetVar> = <RefObj> get max. ware transport class
<RetVar/IF><RefObj> get cargo bay size
<RetVar/IF><RefObj> get free volume of cargo bay
<RetVar/IF><RefObj> get volume of ware <Var/Ware> in cargo bay
<RetVar/IF><RefObj> get true volume of ware <Var/Ware> in cargo bay
<RetVar/IF><RefObj> get free volume of ware <Var/Ware> in cargo bay
<RetVar/IF><RefObj> get total volume in cargo bay
<RetVar/IF><RefObj> can transport ware <Var/Ware>
<RefObj> add default items to ship
<RefObj> switch laser in turret<Var/Number> gun <Var/Number> to <Var/Ware>
<RefObj> set wanted ware count to <Var/Number>
<RefObj> set wanted ware to <Var/Ware>
<RetVar> = <RefObj> get wanted ware count
<RetVar> = <RefObj> get wanted ware
<RetVar/IF><RefObj> has illegal ware onboard: race=<Var/Race>
<RetVar/IF><RefObj> get tradeable ware array from ship
<RetVar> = <RefObj> get upgradeable price: cargo-speed-rot <Var/Ware> units:<Var/Number>

Trade Commands - Stations(贸易命令 - 空间站)

<RetVar/IF><RefObj> get best store amount of ware <Var/Ware>
<RetVar/IF><RefObj> get max. store amount of ware <Var/Ware>
<RetVar/IF><RefObj> can buy ware <Var/Ware>
<RetVar/IF><RefObj> can sell ware <Var/Ware>
<RetVar/IF><RefObj> get price of ware <Var/Ware>
<RetVar/IF><RefObj> get average price of ware <Var/Ware>
<RefObj> set price of ware <Var/Ware> to <Var/Number> Cr
<RetVar/IF><RefObj> uses ware <Var/Ware> as primary resource
<RetVar/IF><RefObj> uses ware <Var/Ware> as secondary resource
<RetVar/IF><RefObj> uses ware <Var/Ware> as product
<RetVar/IF><RefObj> trades with ware <Var/Ware>
<RetVar/IF><RefObj> get product ware
<RetVar/IF><RefObj> get number of resources
<RetVar/IF><RefObj> get number of primary resources
<RetVar/IF><RefObj> get number of secondary resources
<RetVar/IF><RefObj> get max trade jumps
<RetVar/IF><RefObj> only player own ships can trade with
<RetVar> = <RefObj> get tradeable ware array from station
<RetVar> = <RefObj> get production cycle time: account for secondary resources=<Var/Number>
<RetVar> = <RefObj> get remaining production cycle time
<RetVar> = <RefObj> get number of products per cycle
<RetVar> = <RefObj> get number of resources per cycle for ware <Var/Ware>
<RetVar> = <RefObj> get production status: as percentage=<Var/Number>
<RefObj> factory production task: on=<Var/Number>
<RetVar/IF><RefObj> get products ----- Does not work
<RetVar/IF><RefObj> get intermediates buyable
<RefObj> set intermediates buyable to <Var/Number>
<RetVar/IF><RefObj> get intermediates sellable
<RefObj> set intermediates sellable to <Var/Number>

Trade Commands - Ships & Stations(贸易命令 - 飞船和空间站)

<RetVar/IF><RefObj> get money
<RefObj> add money: <Var/Number>
<RetVar/IF><RefObj> get amount of ware <Var/Ware> in cargo bay
<RetVar/IF><RefObj> get true amount of ware <Var/Ware> in cargo bay
<RetVar/IF><RefObj> get free amount of ware <Var/Ware> in cargo bay
<RetVar/IF><RefObj> get max amount of ware <Var/Ware> that can be stored in cargo bay

Trade Commands - Merchant(贸易命令 - 商人)

add merchant <Var/String> base=<RefObj> wanted wares=<Var/Array> owned wares=<Var/Array> cash=<Var/Number> rank=<Var/Number>
<RetVar> = <RefObj> get merchants
remove merchant <Var/Sting>
merchant <Var/String> got ware <Var/Ware>: quantity=<Var/Number>
merchant <Var/String> sold ware <Var/Ware>: quantity=<Var/Number>
reset merchant <Var/String> expiry
<RetVar> = get data for merchant <Var/String>: item number=<Var/Number>
<RetVar> = get ware array for <Var/Ship>
<RetVar/IF><RefObj> lock ware: <Var/Ware> on station: <Var/Station> for this
<RetVar/IF><RefObj> get defined amount of ware <Var/Ware> as ship hardware
<RetVar/IF><RefObj> set defined amount of ware <Var/Ware> as ship hardware
<RetVar> = <RefObj> get ship hardware as array

General Object Commands(普通对象命令)

<RetVar/IF><RefObj> get object class
<RetVar/IF><RefObj> get owner race
<RetVar/IF><RefObj> get environment
<RetVar/IF><RefObj> get sector
<RetVar/IF><RefObj> get homebase
<RetVar/IF><RefObj> is of class <Var/Class>
<RetVar/IF><RefObj> exists
<RetVar/IF><RefObj> get ware type code of object
<RefObj> set serial name of station to <Var/Stations Serial>
<RetVar/IF><RefObj> get serial name of station
<RetVar/IF> find station in galaxy: startsector= <Var/Sector> class or type=<Value> race=<Var/Race> flags=<Var/Number> refobj=<Value> serial=<Var/Stations Serial> max.jumps=<Var/Number>
<RetVar/IF><RefObj> is of type <Var/Ship Type/Station Type>
<RetVar/IF> get jumps from sector <Var/Sector> to sector <Var/Sector>
<RetVar/IF> get next sector on route from sector <Var/Sector> to sector <Var/Sector>
<RefObj> set homebase to <Var/Ship/Station>
<RetVar/IF><RefObj> get current shield strength
<RetVar/IF><RefObj> get maximum shield strength
<RetVar/IF><RefObj> get current laser strength
<RetVar/IF><RefObj> get maximum laser strength
<RetVar/IF><RefObj> get max laser strength in turret <Var/Number>
<RetVar/IF><RefObj> get max. shield type that can be installed
<RetVar/IF><RefObj> get number of shield bays
<RetVar/IF><RefObj> get number of laser bays
<RetVar/IF><RefObj> get most destructive missile type that can be installed
<RetVar/IF><RefObj> get relation to object <Var/Ship/Station>
<RetVar/IF><RefObj> get relation to race <Var/Race>
<RetVar/IF><RefObj> get notoriery to race <Var/Race>
<RetVar/IF> get notoriery from race <Var/Race> to race <Var/Race>
<RetVar/IF><RefObj> is <Var/Ship/Station> a enemy
<RetVar/IF><RefObj> is <Var/Ship/Station> a friend
<RetVar/IF><RefObj> is <Var/Ship/Station> neutral to me
<RetVar/IF><RefObj> get shield type in bay <Var/Number>
<RetVar/IF><RefObj> get laser type in bay <Var/Number>
<RetVar/IF><RefObj> has same environment as <Var/Ship/Station>
<RetVar/IF><RefObj> is in same sector as <Var/Ship/Station>
<RetVar/IF><RefObj> is landed
<RetVar/IF><RefObj> is docked
<RetVar/IF><RefObj> is docking possible of <Value>
<RetVar/IF><RefObj> is docking allowed at <Var/Ship/Station>
<RetVar/IF><RefObj> is in sector
<RetVar/IF><RefObj> get attacker
<RefObj> set attacker to <Var/Ship/Station>
<RetVar> = get distance between <Var/Ship/Station> and <Var/Ship/Station>
<RetVar> = <RefObj> get distance to: x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar> = <RefObj> get distance to: position array=<Var/Array>
<RetVar> = get distance: position array1=<Var/Array> array2=<Var/Array>
<RetVar> = create ship: type=<Var/Ship Type> owner=<Var/Race> addto=<Value> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar> = <RefObj> get x position
<RetVar> = <RefObj> get y position
<RetVar> = <RefObj> get z position
<RetVar> = <RefObj> get position as array
<RetVar> = get player ship
<RefObj> set relation against <Value> to <Relation>
<RetVar> = create station: type=<Var/Station Type> owner=<Var/Race> addto=<Var/Sector> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar> = create gate: type=<Var/Number> addto=<Var/Sector> gateid=<Var/Number> dstsecx=<Var/Number> dstsecy=<Var/Number> dstgateid=<Var/Number> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar> = create asteroid: type=<Var/Number> addto=<Var/Sector> resource=<Var/Number> yield=<Var/Number> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RefObj> add product to factory or dock: <Var/Ware>
<RefObj> add primary resource to factory: <Var/Ware>
<RefObj> add second resource to factory: <Var/Ware>
<RefObj> remove product from factory or dock: <Var/Ware>
<RefObj> remove primary resource from factory: <Var/Ware>
<RefObj> remove second resource from factory: <Var/Ware>
<RetVar> = create nebula: type=<Var/Number> addto=<Var/Sector> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar> = create sun: subtype=<Var/Number> r=<Var/Number> g=<Var/Number> b=<Var/Number> addto=<Var/Sector> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar> = create planet: subtype=<Var/Number> addto=<Var/Sector> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar> = create special: type=<Var/Number> addto=<Var/Sector> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RetVar/IF> find ship: sector=<Var/Sector> class or type=<Value> race=<Var/Race> flags=<Var/Number> refobj=<Value> maxdist=<Var/Number> maxnum=<Var/Number> refpos=<Var/Array>
<RetVar/IF> find asteroid: sector=<Var/Sector> resourcetype=<Var/Number> min.yield=<Var/Number> flags=<Var/Number> refobj=<Value> maxdist=<Var/Number> maxnum=<Var/Number> refpos=<Var/Array>
<RetVar/IF> find flying ware: sector=<Var/Sector> maintype=<Var/Number> subtype=<Var/Number> flags=<Var/Number> refobj=<Value> maxdist=<Var/Number> maxnum=<Var/Number> refpos=<Var/Array>
<RetVar/IF> find station: sector=<Var/Sector> class or type=<Value> race=<Var/Race> flags=<Var/Number> refobj=<Value> maxdist=<Var/Number> maxnum=<Var/Number> refpos=<Var/Array>
<RetVar/IF><RefObj> is disabled
<RefObj> station trade and production tasks: on=<Var/Number>
<RetVar/IF><RefObj> get SectorObject ID
<RetVar> = get ware type of SectorObject <Var/Number>
<RetVar/IF> exists SectorObject <Var/Number>
<RetVar/IF> get object from SectorObject <Var/Number>
<RefObj> destruct: show no explosion=<Var/Number>
<RefObj> set position: x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RefObj> set rotation: alpha=<Var/Number> beta=<Var/Number> gamma=<Var/Number>
<RetVar> = create flying ware: maintype=<Var/Number> subtype=<Var/Number> count=<Var/Number> sector=<Var/Sector> x=<Var/Number> y=<Var/Number> z=<Var/Number> selfdestruct=<Var/Number>
<RetVar> = <RefObj> get rot alpha
<RetVar> = <RefObj> get rot beta
<RetVar> = <RefObj> get rot gamma
<RetVar> = <RefObj> get size of object
<RetVar/IF><RefObj> get max upgrades for upgrade <Var/Ware>
<RetVar/IF><RefObj> get max speed
<RetVar/IF><RefObj> get max hull
<RetVar/IF><RefObj> get hull
<RetVar/IF><RefObj> get hull percent
<RetVar/IF><RefObj> get shield percent
<RetVar/IF><RefObj> get shield and hull percent
<RetVar/IF><RefObj> get max upgraded speed
<RetVar/IF><RefObj> get dock bay size
<RetVar/IF><RefObj> get number of landed ships
player loses police licence for race <Var/Race>
<Var/Race> add notoriety: race=<Var/Race> value=<Var/Number>
<RefObj> set ship disabled to <Var/Number>
<RefObj> put into environment <RefObj>
<RefObj> station send defend squad against ship <Var/Ship/Station>
<RetVar/IF> = <RefObj> get name
<RefObj> set name to <Var/String>
<RefObj> set owner race to <Var/Race>
<RetVar/IF><RefObj> find ship: class or type=<Value> race=<Var/Race> flags=<Var/Number> refobj=<Value> maxnum=<Var/Number> with homebase=<Value>
<RetVar/IF> = find station in galaxy: startsector=<Var/Sector> class or type=<Value> race=<Var/Race> flags=<Var/Number> refobj=<Value> serial=<Var/Stations Serial> max.jumps=<Var/Number> num=<Var/Number>
<RetVar> = <RefObj> get ID code
<RetVar> = <RefObj> get pilot name
<RefObj> set pilot name to <Var/String>
<RefObj> set pilot speaker: voice=<Value>, face=<Value>, Pirate subrace=<Value>, Argon female=<Value>
<RefObj> set hull to <Var/Number>
<RefObj> set current shield strength to <Var/Number>
<RetVar> = <RefObj> get current max speed
<RetVar> = get fight rank
<RetVar> = get trade rank
<RetVar> = <RefObj> is known
<RefObj> set known status to <Var/Number>
<RetVar> = <RefObj> is detectable
<RetVar> = <RefObj> is hired
<RetVar> = <RefObj> serialise object
<RetVar> = get player name
<RefObj> disable ship rebuild
<RetVar> = <RefObj> get current speed
<RetVar> = order ship in next shipyard: owner=<Var/Race> sector=<Var/Sector> class=<Var/Class> optional: default shiptype for race: <Var/Race>
<RetVar/IF> = find nebula: sector=<Var/Sector> type=<Var/Number> effect=<Var/Number> flags=<Var/Number> refobj=<Var/Ship/Station> maxdist=<Var/Number> maxnum=<Var/Number> refpos=<Var/Array>
<RetVar> = <RefObj> is hidden
<RefObj> start job
START <RefObj> command: arg1=<Value>, arg2=<Value>, arg3=<Value>, arg4=<Value>
<RetVar> = <RefObj> get true owner
<RetVar> = create debris: type=<Var/Number> addto=<Var/Sector> resource=<Var/Number> yield=<Var/Number> x=<Var/Number> y=<Var/Number> z=<Var/Number>
<RefObj> add lasers per value:<Var/Number> flags:<Var/Number>
<RefObj> add shields per value:<Var/Number>
<RetVar/IF><RefObj> is asteroid scanned
<RefObj> set asteroid scanned to <Var/Number>
<RetVar> = <RefObj> get flying ware count
<RetVar> = <RefObj> get pilot morale
<RetVar> = <RefObj> get pilot aggression
set notoriety of <Var/Race> -> <Var/Race> to <Var/Number> points
<RetVar/IF> find debris: sector= <Var/Sector> resource= <Var/Ware> min yield=<Var/Number> flags= <Var/Number> refobj= <Value> num=<Var/Number> max distance= <Var/Number> refpos= <Var/Array>

General Object Commands - Weapon Information(普通对象命令 - 武器信息)

<RetVar> = get power generator of ship/station type <Var/Ware>
<RetVar> = <RefObj> get power generator
<RetVar> = get range of laser <Var/Ware>
<RetVar> = get shield damage of laser <Var/Ware>
<RetVar> = get hull damage of laser <Var/Ware>
<RetVar/IF>get ammunition of laser <Var/Ware>
<RetVar> = get missile range of <Var/Ware>
<RetVar> = get missile max damage of <Var/Ware>

Universe / Sector Commands(宇宙和星区命令)

<RetVar/IF> get sector from universe index: x=<Var/Number>, y=<Var/Number>
<RetVar> = get max sectors in x direction
<RetVar> = get max sectors in y direction
<RetVar/IF><RefObj> is sector known by the player
<RetVar> = <RefObj> get universe x index
<RetVar> = <RefObj> get universe y index
<RetVar/IF><RefObj> get warp gate: gate id=<Var/Number>
<RetVar> = <RefObj> get north warp gate
<RetVar> = <RefObj> get south warp gate
<RetVar> = <RefObj> get east warp gate
<RetVar> = <RefObj> get west warp gate
<RetVar> = find a random sector: startsector=<Var/Sector>, jumps=<Var/Number>, owner=<Var/Race>
<RetVar> = <RefObj> get ship array from sector/ship/station
<RetVar> = <RefObj> get station array from sector
<RetVar> = <RefObj> get factory array from sector
<RetVar> = <RefObj> get dock array from sector
<RetVar> = <RefObj> get player owned ship array from sector
<RetVar> = <RefObj> get player owned station array from sector
<RetVar> = <RefObj> get asteroid array from sector
<RetVar> = <Var/Warpgate> get gate destination: return sector=<Var/Number>
<RetVar> = <Var/Warpgate> get gate id
<RetVar/IF><RefObj> get owned ships: class/type=<Value>
<RetVar> = get ship array: of race <Var/Race> class/type=<Value>
<RetVar> = get station array: of race <Var/Race> class/type=<Value>
<RetVar/IF> = get next gate on route from <Var/Sector> to <Var/Sector>
<RetVar> = get random NPC
<RetVar> = <RefObj> get NPC personal ship
<RefObj> NPC send voice message: id= <Var/Number>
<RefObj> release NPC personal ship
<RefObj> release NPC
<RetVar> = <RefObj> NPC wants to bail
<RetVar> = <RefObj> NPC is aggressive
<RefObj> spawns NPC personal ship: rank=<Var/Number>
<RefObj> spawns NPC fleet: rank=<Var/Number>
<RetVar> = <RefObj> get NPC fleet
<RetVar> = <RefObj> get asteroid yield
<RetVar> = find a random sector: startsector=<Var/Sector>, jumps=<Var/Number>, owner=<Var/Race>, security level=<Var/Number>
<RetVar> = <RefObj> get resource waretype of asteroid
<RetVar/IF> <RefObj> has collectable rocks

▲评论

› 网友 adie () 于 2011-10-18 14:05:09 发表评论说:

编辑的脚本保存的位置:

C:\Users\当前登录的用户名\AppData\Local\VirtualStore\Program Files\DeepSilver\X3 Reunion\scripts

› 网友 wholesale bags (sex:dvxvqhj@gmail.com; email:wholesale bags; web:http://www.googletest.com; qq:wholesale bags; from:wholesale bags; work:wholesale bags; ) 于 2014-02-18 12:32:06 发表评论说:

X3:Reunion 脚本编写指南 - 阿呆软件工作室