查看“Skript”的源代码

{{待翻译}}
{{待完善}}
==原文地址==
http://njol.ch/projects/skript/

== 介绍 ==
Skript是一个流行的服务器插件。

它允许服务器管理员在不写任何Java语言的情况下简单的管理Minecraft。

这是用触发器、条件和效果三个部分做到的。

当触发器触发，所有条件均满足，效果就会被触发。

Skript的基础想法是——自定义 —— 每个服务器都能在没有自定义插件的情况下表现不同。

这比你自己钻研插件和找人写插件快的多。

同时你也不需要那么多小插件了，这一个插件就够了。

你可以在[[https://github.com/bensku/Skript/releases 这里]]<ref>原文给的是DropBox地址无法访问，这里是作者的GitHub地址</ref>下载最新版本的Skript

已经提及了，Skript的触发器提供了这个插件的基本功能。

触发器很普通，并由一些条件和效果组成，就像这个简单的掉落修复脚本:


<pre>

on break of glass:
    drop glass
译者注:
当打破玻璃的时候:
    掉落玻璃
</pre>


Skript也能用来做自定义命令。

这些基本的触发器已被改成了执行特定的命令。

下面的简单触发器允许玩家在手持物品输入/id时显示它的ID。


<pre>
command /id:
    description: Find the ID of the item you're holding
    trigger:
        message "You're holding a %type of tool% whose ID is %id of tool%."
译者注:
当使用/id时:
    描述: 获取你当前持有物的ID
    触发器:
        给玩家发送消息 "你现在正在拿着一个%type of tool%[工具类型] ，它的ID是 %id of tool%[工具ID]"
</pre>


Skript同时也有直接从聊天栏执行效果的选项，输出一个可配置的符号打头(!是默认的)的聊天信息。

这经常被指令使用。例如， <pre>!repair tool</pre>，将会修复你的工具。因为这些指令非常强大且用的地方很多。

只有在玩家拥有<pre>skript.effectcommands</pre>权限时才能使用(OP默认不拥有!)

Skript的语法不仅限制于上面的简单指令，还包括一些循环，包含等语法。

下面的脚本是一个很简单的从附近箱子抽调燃料的例子——
<pre>
on burn of fuel:
    fuel slot of the block is empty
    loop blocks in radius 1:
        loop-block is chest
        loop items of type fuel:
            loop-block contains loop-item
            remove loop-item from loop-block
            set fuel of the event-block to loop-item
            stop trigger
译者注:
当燃料燃烧时:
    熔炉的燃料槽空了
    在周围半径一格寻找方块:
        寻找箱子
        寻找物品是燃料类型
            箱子包含燃料
            从箱子中移除燃料
            把燃料移到燃料槽
            停止触发器
</pre>
更多信息请前往[[https://dev.bukkit.org/bukkit-plugins/skript/ BukkitDev]]<ref>译者注:作者的BukkitDev已经停止更新，请前往GitHub，在文章开始处</ref>，然后也请阅读下面的教程和帮助文档。

教程是新手的必读品。它解释了如何写一个脚本。这里是[[https://dev.bukkit.org/bukkit-plugins/skript/pages/general-tutorial/ 另一段教程]]<ref>译者注: 两段都翻译了</ref>

帮助文档是所有触发器的集合，这里面有所有关于脚本的东西。


[[http://dev.bukkit.org/bukkit-plugins/skript/ 链接到BukkitDev]]

[[http://dev.bukkit.org/bukkit-plugins/skript/forum/ 链接到作者论坛]]

== 教程 ==
===作者在自带页面给出的教程===
====开始====
在你开始写脚本之前你应该先安装Skript插件

下载最新的Skript插件，把它放入plugins，重启服务器来生成配置和一些示例脚本。

====写触发器====
在你打开你的编辑器之前我推荐你知道你要写什么脚本，但你可以简单地开始写了。

在这个教程中我会说明如何写一个用锄头来直接撒播种子的脚本。

它应该包括 当一个人手持锄头右键泥土时自动种植作物。

首先，打开你的文档编辑器[例如NotePad++] <ref>译者注:经测试，不推荐使用微软自带的记事本!</ref>

现在思考怎么样能让你的触发器被触发，所以我们写下第一行：
<pre>
on right click:
译者注：
在右键时:
</pre>
如果你不知道有哪些条件可以触发的话，点击[[http://njol.ch/projects/skript/doc/events/ 这里]]<ref>译者注:这里是下面帮助文档的Events 事件大类</ref>

但是我们不想让人们右键都触发，只是在泥土上用锄头而已。

所以我们应该改变一下——
<pre>
on right click on soil holding a hoe:
译者注:
当持有锄头右键泥土时:
</pre>
我们也可以用这个事件+条件来替代——
<pre>
on right click:
    block is soil
    player is holding a hoe
译者注:
当右键时：
    方块是泥土
    玩家手持锄头
</pre>

这两种都可以，但我在这篇文档中将使用第一种。

然后我们来检测玩家有无种子:
<pre>
on right click on soil holding a hoe:
    player has seeds
译者注:
当用锄头右键泥土时：
    玩家拥有种子
</pre>

请注意第二行的缩进。这会使读取器认为这是一个触发器中的语句，并且使脚本更简单的阅读。

如果你不注意这个缩进的话你的插件就会报错因为插件认为他们不属于一个触发器。

在那之后我们应该种植作物了——
<pre>
on right click on soil holding a hoe:
    player has seeds
    set block above the clicked block to crops
译者注:
当手持锄头右键泥土时：
    玩家拥有种子
    将泥土上方的方块设置为作物
</pre>
这不是很精确因为可能我们点击的泥土方块上方有方块(如下图)

[_] <- 其他方块

[_] <- 泥土方块

如果我们只是设置的话我们会覆盖掉原有方块。

这可能是别的玩家领地中的物品甚至是基岩。

这样的问题看起来并不明显但会有BUG的存在。你可以在你服务器上使用之前先在一个测试服务器上尝试运行。

这个问题可以用检测泥土上方的方块来解决——
<pre>
on right click on soil holding a hoe:
    player has seeds
    block above the clicked block is air
    set block above the clicked block to crops
当手持锄头右击方块时:
    玩家拥有种子
    被点击方块的上面是空气
    把点击方块上面的方块设置为作物
</pre>
然后不要忘了移除玩家的种子，不然他们就有免费作物了：D
<pre>
on right click on soil holding a hoe:
    player has seeds
    block above the clicked block is air
    set block above the clicked block to crops
    remove seeds from player
当手持锄头右击方块时:
    玩家拥有种子
    被点击方块的上面是空气
    把点击方块上面的方块设置为作物
    移除玩家的种子
</pre>

最后一件事是把你的脚本储存到 <pre>./plugins/Skript/scripts</pre>里，你可以取任何名字。

但请不要以<pre>-</pre>号打头，因为这会使脚本无法读取。

文件的扩展名必须是<pre>.sk</pre>，例如，你可以把这个脚本储存为<pre>hoe.sk</pre>


现在开启你的服务器[可能是测试的]，检查后台有无错误信息，如果有，尝试修复。

然后登入服务器测试脚本查看是不是都可以运行。

如果你测试完毕，你可以上传到你的主服务器让玩家使用了。

你也可以使用<pre>/sk reload 脚本名称</pre>来使脚本重载。这方便你调试脚本，不要重启服务器。

所有的错误将会发送给使用指令的玩家。

如果后台使用，将发送给后台。

===BukkitDev给出的教程===
Skript的目标就是让不会语法的程序员们写他们自己的小插件[称之为脚本]。

我感觉这个目的渐渐的被人淡化因为人们也不会写脚本。

这个教程教写脚本的新人，如何让这个绝妙的插件在TA的服务器上工作。

[[http://njol.ch/projects/skript/doc 帮助文档]]解释了你服务器所需要的所有的脚本构成。
 
我不是这里单一的教程帖子了，我将会引用一些他们的东西。

这个插件在你自己编程的时候非常有用，你可以做你想做的东西，以及它不需要完美的语法。

帮助文档可以在这篇文章的最上方找到。

变量，循环，指令，条件和事件——
你写脚本的时候，你最少要用到一个，甚至你可能都需要。
下面我会详细介绍每个是干什么的，什么时候用他们——

====事件====

事件就是当一件事情发生的时候，例如玩家点击了一些东西，打出伤害，狗带，或一个怪物做了一些事情，甚至是环境自己改变。

这允许你做一些另外的事情——例如:

<pre>
on explode:
        cancel event
当爆炸时:
        取消事件的发生
</pre>
注意空格，事件后都有一个冒号。你可以用4个或8个空格<ref>译者从来没有试过8个，都是4个</ref>。

你不能使用tab或空格来换行。我偏向于使用tab来缩进因为我只需要点一次<ref>译者喜欢4个空格 因为这样语法感觉更好</ref>

真正的事件其实非常简单。当一个爆炸发生，取消它。

这能很好地防止TNT 苦力怕的爆炸，甚至防止末影龙。

记住这个会真正的取消爆炸，就是玩家也不会受到伤害。

所以这个脚本非常简单，你可以简单的变换结局。

例如杀死服务器上的所有玩家<Ref>这个人怎么想的=-=</ref>

====条件====

条件是任何脚本的基础。他们是执行下一部分的条件代码。一个权限示例如下——
<pre>
on rightclick:
        player has permission "skript.boom"
        create explosion with force 3 at targeted block
当右键时:
        玩家拥有"skript.boom"权限
        在指向方块处创造力量为3的爆炸
</pre>

这会创建一个比TNT更小的爆炸，但只会在玩家拥有对应权限时工作。

条件能被用来检查玩家是否拥有物品，或牌子上写的东西。

你甚至可以用多个条件来限制效果。

<pre>
on rightclick:
        block is a sign
        line 1 of sign is "[Shop]"
        player has permission "skript.shop"
        player has 2 gold nuggets
        remove 2 gold nuggets from player
        give player 1 bread
        message "<light green>You bought a bread."
</pre>
在这个脚本中玩家必须右击一个第一行为[Shop]的牌子，拥有权限，2个金粒，然后才能有效果。

====指令====

每个服务器的管理员都知道指令，这是你运营服务器的方式。 Skript允许你自己自定义指令。这些命令与事件写法大体相似，除了事件需要被你自定义。

这个事件简单的版本是通过玩家输入指令来自定义效果。如果想获取更好的想法，看我下面的例子。
<pre>
command /hi:
        permission: skript.hi
        trigger:
                message "hi"
</pre>
这个简单的命令给发送/hi的玩家发送消息。第一行是事件。首先我们说要自定义一个命令，然后我们写什么命令。

然后我们给它一个权限和使用方法。最后，我们增加触发器，使我们想要指令做的事情。

你可以看网页提及的自定义命令的部分。

你也可以做一些可以获取信息的指令，或者指定被作用效果的玩家。看下面的指令:
<pre>
command /hi <player>:
        permission: skript.hi
        trigger:
                send "hi" to argument
</pre>
这个命令和之前一样发送同样的消息，但这次将会发送给别的玩家。

我们使用这个发送效果的原因是因为消息效果只发送消息给事件中的玩家，而不是输入指令的玩家。

有了发送效果，我们就能够给别的玩家发送信息了。

argument是指令中的玩家，所以当你使用/hi demon_penguin时，将会给 demon_penguin 发送hi。

同时你也可以查看网页来了解更多关于自定义命令的信息。

====循环====

循环任务可以用来完成复杂的任务。例如如果你想检测在你附近是不是有个箱子，你可能要检测你周围所有的方块来查看它是不是箱子。这可以用一个简单的循环解决——
<pre>
command /chest:
        trigger:
                loop blocks in radius 3 around player:
                        loop-block is a chest
                        message "There is a chest at %location of loop-block%"
</pre>

牌子上的变量会取代它的文本。这里有 x y z三个变量来代替 %location of loop-block%。

循环代码的一部分是任何方块的循环检查。 循环将会在玩家3格半径的范围内寻找箱子

因为我们在用一个自定义指令，我们可以增加寻找的范围和arguments来允许玩家选择距离。
<pre>
command /chest <integer=3>:
        trigger:
                loop blocks in radius argument around player:
                        loop-block is a chest
                        message "There is a chest at %location of loop-block%"
</pre>
这里我们为指令设置了默认值，如果在玩家没有选择的情况下为3.在循环表达中我们将argument代替了数字。

这意味着无论你输入什么数字，指令都会把其读取。如果没有输入数字，3将会成为默认值。

如果你想要看精确的半径的话，做一个圆球脚本，你就能看见尺寸了。
<pre>
command /sphere <integer=3>:
        trigger:
                loop blocks in radius argument around player:
                        loop-block is air
                        set loop-block to stone
                set {clear.block} to location of player
                set {clear.radius} to argument

command /clear:
        trigger:
                loop blocks in radius {clear.radius} around {clear.block}:
                        loop-block is stone
                        set loop-block to air
</pre>
/clear指令将会轻松删掉你设置的圆球。同样因为你在圆球的中心，你要想一个让自己出去的方法。

这个指令可能会对地面造成一些伤害，所以请飞行来使用。

{}中的东西叫做变量，下节会说到。如果你想了解更多关于循环的知识请看帮助文档。

====变量====

变量是用来在名字下储存数据的。它像一个盒子上的标签，如果你想要知道盒子里的信息，只要找到正确的标签就可以。Skript的变量就是这样。你可以像这样储存变量:
<pre>
set {variable.name.goes.here} to true
</pre>
变量值可以是true/false ，一个坐标，或数字。这样的原因是我们可以晚些获得这个信息。所以也许我们可以检查玩家是否输入过指令，我们可以这样做：
<pre>
command /sethome:
        trigger:
                set {home} to location of player

command /home:
        trigger:
                teleport player to {home}
</pre>
你的变量必须用{}括起来，因为这才能告诉Skript这是一个变量。上面是一个非常简单的家园脚本。

我们记录玩家的位置在一个叫做{home}的'盒子'里。当玩家输入/home时因为有变量所以我们知道把玩家传送去哪里。这不会把变量清除，它更偏向于只读类型。

即读取后放回原处。但在你写脚本中，你必须思考用户可能出错的方式。

例如玩家并没有设置他的家，那么在用/home后会发生什么？他们会被传送到哪里？

这你需要使用if来检测。检测是否有一些错误，如果没有，再继续执行脚本。

上面的脚本并不会给玩家发送信息，所以你需要自己创建——
<pre>
command /sethome:
        trigger:
                set {home} to location of player

command /home:
        trigger:
                if {home} is not set:
                        message "<red>You need to set a home first!"
                        stop trigger
                teleport player to {home}
</pre>
现在当玩家尝试用/home时他们会受到错误提示并且剩下的脚本不会运行。

如果你忘记停止脚本，剩下的事件将照常继续运行。同时如果同时如果if判断的是false,那么剩下的代码便不会运行，玩家也收不到错误消息。

现在我们这个脚本主要的问题是当一个人/sethome后，另一个人使用/home可以直接到达这个位置。

然后在另一个人设置家后，便会覆盖前一个人家的记录。

修复它的方法是使用表达式。这些可以读取触发事件的人。

在这样输入指令后，会记录谁输入的指令。

所以让每个人都有不同的家，我们其实可以用玩家的名字作为变量。例如这样——
<pre>
command /sethome:
        trigger:
                set {home.%player%} to location of player

command /home:
        trigger:
                if {home.%player%} is not set:
                        message "<red>You need to set a home first!"
                        stop trigger
                teleport player to {home.%player%}
</pre>
现在玩家的名字在变量中了，所以当检测是否存在时，对我将会检测{home.demon_penguin}，对别人将会检测 {home.whateveryouruseernameis}。
 
在这个脚本中每个人都会有他们自己家的位置了。

====注意事项====

记住你学到的命令部分下所有的东西，都可以使用在任何触发器中。

这其中包括许多事件。

如果你想了解更多，看帮助文档吧<ref>下面的内容</ref>。

如果你关于我说的有任何疑问，或要寻求帮助等，请在这里发帖 [[http://dev.bukkit.org/server-mods/skript/forum/help/ 传送点]]

-Demon 原作者
-c7w 翻译者

== WIKI帮助文档==
===总帮助===
写Skript触发器并不比描述它的条件更难。

因为许多你想做的事情都与事件，例如放置方块，拉动拉杆开关，所有的触发器在触发时都被自定义。

这叫做触发器的事件。无论事件什么时候产生 , 例如当一个玩家放置一个方块，插件将会依次检测触发器的条件.如果满足所有触发条件,触发器将执行. 
下面是一个单一事件,条件,效果的简单例子:
<pre>
# 第一行就是事件:
on place of sand:
	# condition:
	block below is air
	# effect:
	send "Watch the sand falling!" to player
</pre>
这样你就领会了这个事件是干嘛的——检测放了沙子的玩家，然后如果下面是空气，就会有发送消息。

若要写触发器，新建一个文件，然后把它保存到  Skript/scripts/ directory /‘名字.sk’, 如 ‘plant with hoe.sk’.

你可以使用任意名，但最好与内容有关。

然后你需要重启你的服务器或使用<pre>/skript reload</pre>来使这个触发器工作。

如果你是重启服务器，检查有无错误。如果使用指令，若有错误会直接发送给你。

一般来说如果你得到许多错误信息应该是表明无法读取你的信息，并且一般会告诉你哪儿错了。如果你是得到这种报错 can't understand '...' or '...' is not a(n) ... 检查你的拼写。

你可以继续阅读以获取所有事件 条件 效果。

如果你需要帮助请去论坛反馈。一般在反馈前请仔细阅读本帮助文献，它一般可以回答你的问题。

你也可以看看别人的教程，如果我的教程不适合你的话。

====高级语法====
Skript的高级语法并不限制于简单的陈述,但比这个更复杂
若要使 ‘tool of …’ 或 ‘block below/north of/above …’ 可能,你要使用表达式，请继续向下阅读。

有时触发器语法的基本语法也比较高级。以下章节包括这些特殊情况。

====条件====
一个很棒的特性是条件陈述。这样的陈述是触发器的一部分，但只有当主部分满足时才会被检查，像这样—— 
主条件[又称事件]:
	条件
	条件满足继续执行
满足条件后可以继续缩进
你也可以使用else: 来在不满足条件的情况下使用——
如下
<pre>
on login:
	chance of 50%:
		give a cake to the player
		send "You got a gift for logging in =)" to the player
	else:
		send "You were not fortunate enough to get a gift this time. Try again next time!" to the player
</pre>
这个脚本会在玩家登入的时候有几率给予玩家一个蛋糕，但如果没有接收到会给玩家说他们不够幸运。
====循环====
循环可以减少触发器内的重复任务，当前来说可以循环的东西还是很少，如变量，物品，方块，玩家。

循环很简单，这就是格式
<pre>
要循环的值:
	关于这个值做一些是
条件在循环中不同，如果条件没有满足，会跳过条件继续执行下面的代码。如果你想停止执行，请这样使用——
<pre>
condition:
	exit loop
</pre>
你也可以使用‘exit’ 或 ‘exit trigger’.

这儿就有一个示例，他会在使用/find时找寻附近的方块。
<pre>command /find <material>:
	description: Find a block of the given material
	trigger:
		loop blocks in radius 10:
			loop-block is argument
			message "Found a %argument% block at %location of loop-block%"
			stop trigger
		send "There's no %argument% block around!" to player
</pre>

===事件===
下面的列表内容是你可以开始一个触发器的事件。

每个触发器只能有一个事件，你不能在给出的语法外自行创造事件。

请注意每个事件前面的on都是完全可选的，不过我加上会感觉更好：D

请注意如果事件只有一种触发方式的话就没有例子。

====At time====
<pre>
模型:
at %time% [in %worlds%]
加入的版本:
1.3.4
关于Minecraft中所有/任一世界的时间
示例:
at 18:00
at 7am in "world"
</pre>
====On Bed Enter====
<pre>
模型:
[on] bed enter[ing]
[on] [player] enter[ing] [a] bed
加入的版本:
1.0
当玩家上床时
</pre>
====On Bed Leave====
<pre>
模型:
[on] bed leav(e|ing)
[on] [player] leav(e|ing) [a] bed
加入的版本:
1.0
当玩家离开床
</pre>
====On Block Damage====
<pre>
模型:
[on] block damage
加入的版本:
1.0
当玩家开始打方块，你可以用来探测左键
</pre>
====On Break / Mine====
<pre>
模型:
[on] [block] (min(e|ing)) [[of] %item types%]
加入的版本:
1.0 (break), unknown (mine)
当方块被玩家破坏。如果使用on mine的话，只有掉落东西才会触发触发器。
示例:
on mine
on break of stone
on mine of any ore
</pre>
====On Bucket Empty====
<pre>
模型:
[on] bucket empty[ing]
[on] [player] empty[ing] [a] bucket
加入的版本:
1.0
当玩家把桶里的东西倒出，可以检测水和岩浆的放置事件。
</pre>
====On Bucket Fill====
<pre>
模型:
[on] bucket fill[ing]
[on] [player] fill[ing] [a] bucket
加入的版本:
1.0
当玩家在桶里装东西，可以检测水和岩浆的破坏事件。
</pre>
====On Burn====
<pre>模型:
[on] [block] burn[ing] [[of] %item types%]
加入的版本:
1.0
当方块被火燃烧
示例:
on burn
on burn of wood, fences, or chests</pre>
====On Can Build Check====
<pre>模型:
[on] [block] can build check
加入的版本:
1.0 (基础), 2.0 (可以取消事件发生)
当玩家手持一个方块或能防止的物品时右击方块被触发。你可以取消这个事件，来防止方块被放置。
只支持物品ID的检查，不允许数据值</pre>
====On Chat====
<pre>模型:
[on] chat
加入的版本:
1.4.1
当玩家聊天时.</pre>
====On Chunk Generate====
<pre>模型:
[on] chunk (generat|populat)(e|ing)
加入的版本:
1.0
当区块被创建</pre>
====On Chunk Load====
<pre>模型:
[on] chunk load[ing]
加入的版本:
1.0
当区块读取</pre>
====On Chunk Unload====
<pre>模型:
[on] chunk unload[ing]
加入的版本:
1.0
当区块被卸载，可以取消事件</pre>
====On Click====
<pre>模型:
[on] [(right|left)[( |-)]][mouse[( |-)]]click[ing] [on %entity type/item type%] [(with|using|holding) %item type%]
[on] [(right|left)[( |-)]][mouse[( |-)]]click[ing] (with|using|holding) %item type% on %entity type/item type%
加入的版本:
1.0
当玩家空手点击方块、空气和实体
在玩家没有看向方块/手拿东西时是无法检测的
示例:
on click
on rightclick holding a fishing rod
on leftclick on a stone or obsidian
on rightclick on a creeper
on click with a sword</pre>
====On Combust====
<pre>模型:
[on] combust[ing]
加入的版本:
1.0
当实体开始燃烧
</pre>
====On Command====
<pre>模型:
[on] command [%text%]
加入的版本:
2.0
当玩家输入一个指令
使用这个事件不如自定义命令，改变权限的方式不能预防某些指令，记录命令，检测其他插件。
示例:
on command
on command "/stop"
on command "pm Njol "</pre>
====On Connect====
<pre>模型:
[on] [player] connect[ing]
加入的版本:
2.0
当玩家连接服务器，这在玩家加入服务器之前运行。
示例:
on connect:
	player doesn't have permission "VIP"
	number of players is larger than 20
	kick the player due to "The last 5 slots are reserved for VIP players."</pre>
====On Consume====
<pre>模型:
[on] [player] ((eat|drink)[ing]|consum(e|ing)) [[of] %item types%]
加入的版本:
2.0
当玩家吃/喝一些东西</pre>
====On Craft====
<pre>模型:
[on] [player] craft[ing] [[of] %item types%]
加入的版本:
unknown
当玩家合成物品</pre>
====On Creeper Power====
<pre>模型:
[on] creeper power
加入的版本:
1.0
当苦力怕被充能</pre>
====On Damage====
<pre>模型:
[on] damag(e|ing) [of %entity type%]
加入的版本:
1.0
当实体接受攻击
示例:
on damage
on damage of a player</pre>
====On Death====
<pre>模型:
[on] death [of %entity types%]
加入的版本:
1.0
实体死亡
示例:
on death
on death of player
on death of a wither or ender dragon:
	broadcast "A %entity% has been slain in %world%!"</pre>
====On Dispense====
<pre>模型:
[on] dispens(e|ing) [[of] %item types%]
加入的版本:
unknown
发射器发射物品</pre>
====On Drop====
<pre>模型:
[on] [player] drop[ing] [[of] %item types%]
加入的版本:
unknown
玩家扔掉物品</pre>
====On Enderman/Sheep====
<pre>模型:
[on] enderman place
[on] enderman pickup
[on] sheep eat
加入的版本:
unknown
末影人搬运方块/羊吃草</pre>
====On Experience Spawn====
<pre>模型:
[on] [e]xp[erience] [orb] spawn
[on] spawn of [a[n]] [e]xp[erience] [orb]
加入的版本:
2.0
当经验值生成时，不能检测其他插件生成的经验。
示例:
on xp spawn:
	world is "minigame_world"
	cancel event</pre>
====On Explode====
<pre>模型:
[on] explo(d(e|ing)|sion)
加入的版本:
1.0
当发生爆炸时</pre>
====On Explosion Prime====
<pre>模型:
[on] explosion prime
加入的版本:
1.0
爆炸前的准备</pre>
====On Fade====
<pre>模型:
[on] [block] fad(e|ing) [[of] %item types%]
加入的版本:
1.0
融化
示例:
on fade of snow or ice</pre>
====On First Join====
<pre>模型:
[on] first (join|login)
加入的版本:
1.3.7
玩家第一次加入游戏</pre>
====On Fishing====
<pre>模型:
[on] [player] fish[ing]
加入的版本:
1.0
玩家钓到了一些东西</pre>
====On Flow====
pre><模型:
[on] [block] flow[ing]
[on] block mov(e|ing)
加入的版本:
1.0
液体流动</pre>
====On Form====
<pre>模型:
[on] [block] form[ing] [[of] %item types%]
加入的版本:
1.0
当一个不是玩家放置的方块创建[下雪，结冰]
示例:
on form of snow
on form of a mushroom</pre>
====On Fuel Burn====
<pre>模型:
[on] fuel burn[ing]
加入的版本:
1.0
熔炉的燃料开始烧</pre>
====On Gamemode Change====
<pre>模型:
[on] game[ ]mode change [to %gamemode%]
加入的版本:
1.0
玩家切换游戏模式
示例:
on gamemode change
on gamemode change to adventure</pre>
====On Grow====
<pre>模型:
[on] grow [of %tree type%]
加入的版本:
1.0
树/蘑菇长大
示例:
on grow
on grow of a tree
on grow of a huge jungle tree</pre>
====On Heal====
<pre>模型:
[on] heal[ing]
加入的版本:
1.0
实体被治疗
</pre>
====On Hunger Meter Change====
<pre>
模型:
[on] (food|hunger) (level|met(er|re)|bar) chang(e|ing)
加入的版本:
1.4.4
当玩家的饥饿值改变</pre>
====On Ignition====
<pre>模型:
[on] [block] ignit(e|ion)
加入的版本:
1.0
方块被燃烧</pre>
====On Item Break====
<pre>模型:
[on] [player] tool break[ing]
[on] [player] break[ing] [(a|the)] tool
加入的版本:
2.1.1
玩家的工具没耐久，自然损坏[这个不能被取消事件]</pre>
====On Item Spawn====
<pre>模型:
[on] item spawn[ing] [[of] %item types%]
加入的版本:
unknown
当有掉落物生成</pre>
====On Join====
<pre>模型:
[on] [player] (login|logging in|join[ing])
加入的版本:
1.0
当玩家加入游戏
示例:
on join:
	message "Welcome on our awesome server!"
	broadcast "%player% just joined the server!"</pre>
====On Kick====
<pre>模型:
[on] [player] (kick|being kicked)
加入的版本:
1.0
当一个玩家被T出游戏</pre>
====On Leaves Decay====
<pre>模型:
[on] leaves decay[ing]
加入的版本:
1.0
树叶消失</pre>
====On Level Change====
<pre>模型:
[on] [player] level [change]
加入的版本:
unknown
玩家等级改变</pre>
====On Lightning Strike====
<pre>模型:
[on] lightning [strike]
加入的版本:
1.0
发生闪电</pre>
====On Move On====
<pre>模型:
[on] (step|walk)[ing] (on|over) %*item types%
加入的版本:
2.0
玩家踩上指定方块
示例:
on walking on dirt or grass
on stepping on stone</pre>
====On Physics====
<pre>模型:
[on] [block] physics
加入的版本:
1.4.6
物理变化
示例:
# prevents sand from falling
on block physics:
	block is sand
	cancel event</pre>
====On Pick Up====
<pre>模型:
[on] [player] (pick[ ]up|picking up) [[of] %item types%]
加入的版本:
unknown
玩家捡起物品</pre>
====On Pig Zap====
<pre>模型:
[on] pig[ ]zap
加入的版本:
1.0
猪变成僵尸猪人</pre>
====On Piston Extend====
<pre>模型:
[on] piston extend[ing]
加入的版本:
1.0
当活塞被激活</pre>
====On Piston Retract====
<pre>模型:
[on] piston retract[ing]
加入的版本:
1.0
当活塞收回</pre>
====On Place====
<pre>模型:
[on] [block] (plac(e|ing)|build[ing]) [[of] %item types%]
加入的版本:
1.0
放置方块
示例:
on place
on place of a furnace, workbench or chest</pre>
====On Portal====
<pre>模型:
[on] [player] portal
加入的版本:
1.0
使用地狱门/末地门</pre>
====On Portal Create====
<pre>模型:
[on] portal create
加入的版本:
1.0
当传送门被创建.</pre>
====On Portal Enter====
<pre>模型:
[on] portal enter
[on] entering [a] portal
加入的版本:
1.0
玩家进入传送门</pre>
====On Pressure Plate / Trip====
<pre>模型:
[on] [step[ping] on] [a] [pressure] plate
[on] (trip|[step[ping] on] [a] tripwire)
加入的版本:
1.0 (pressure plate), 1.4.4 (tripwire)
压力板</pre>
====On Projectile Hit====
<pre>模型:
[on] projectile hit
加入的版本:
1.0
当发射物击中实体或方块[箭 雪球 骷髅头 火球 鸡蛋]</pre>
====On Quit====
<pre>模型:
[on] (quit[ting]|disconnect[ing]|log[ ]out|logging out)
加入的版本:
1.0
当玩家离开游戏</pre>
====On Redstone====
<pre>模型:
[on] redstone [current] [chang(e|ing)]
加入的版本:
1.0
红石流通</pre>
====On Region Enter/Leave====
<pre>模型:
cannot be used directly
加入的版本:
2.1
进入/离开区域[需要区域插件]
示例:
on region exit:
	message "Leaving %region%."</pre>
====On Respawn====
<pre>模型:
[on] [player] respawn[ing]
加入的版本:
1.0
当玩家重生时</pre>
====On Script Load/Unload====
<pre>模型:
[on] [script] (load|init|enable)
[on] [script] (unload|stop|disable)
加入的版本:
2.0
当脚本被读取/卸载
示例:
on load:
	set {running.%script%} to true
on unload:
	set {running.%script%} to false</pre>
====On Shoot====
<pre>模型:
[on] [projectile] shoot
加入的版本:
1.0
当一个发射物被发射</pre>
====On Sign Change====
<pre>模型:
[on] sign (chang[e]|edit)[ing]
[on] [player] (chang[e]|edit)[ing] [a] sign
加入的版本:
1.0
牌子被玩家结束编辑
示例:
on sign change:
	line 2 is empty
	set line 1 to "<red>%line 1%"</pre>
====On Skript Start/Stop====
<pre>模型:
[on] (server|skript) (start|load|enable)
[on] (server|skript) (stop|unload|disable)
加入的版本:
2.0
当插件被读取/卸载
示例:
on Skript start
on server stop</pre>
====On Smelt====
<pre>模型:
[on] [ore] smelt[ing]
[on] smelt[ing] of ore
加入的版本:
1.0
当熔炉开始烧炼矿物</pre>
====On Sneak Toggle====
<pre>模型:
[on] [player] toggl(e|ing) sneak
[on] [player] sneak toggl(e|ing)
加入的版本:
玩家是否潜行
示例:
# make players that stop sneaking jump
on sneak toggle:
	player was sneaking
	push the player upwards at speed 0.5</pre>
====On Spawn====
<pre>模型:
[on] spawn[ing] [of %entity types%]
加入的版本:
1.0
当一个实体生成
示例:
on spawn of a zombie
on spawn of an ender dragon:
	broadcast "A dragon has been sighted in %world%!"</pre>
====On Spawn Change====
<pre>模型:
[on] [world] spawn change
加入的版本:
1.0
当世界的重生点被切换</pre>
====On Spread====
<pre>模型:
[on] spread[ing]
加入的版本:
1.0
当一个新方块生成，原方块可以传播，例如蘑菇和水</pre>
====On Sprint Toggle====
<pre>模型:
[on] [player] toggl(e|ing) sprint
[on] [player] sprint toggl(e|ing)
加入的版本:
unknown
当玩家切换疾跑状态</pre>
====On Tame====
<pre>模型:
[on] [entity] tam(e|ing)
加入的版本:
1.0
当玩家驯服狼/豹猫</pre>
====On Target====
<pre>模型:
[on] [entity] target
[on] [entity] un[-]target
加入的版本:
1.0
当怪物锁定一个实体进行攻击</pre>
====On Teleport====
<pre>模型:
[on] [player] teleport[ing]
加入的版本:
1.0
当玩家被传送</pre>
====On Throwing of an Egg====
<pre>模型:
[on] throw[ing] [of] [an] egg
[on] [player] egg throw
加入的版本:
1.0
当玩家扔鸡蛋</pre>
====On Tool Change====
<pre>模型:
[on] [player['s]] (tool|item held|held item) chang(e|ing)
加入的版本:
1.0
当玩家的工具切换</pre>
====On Vehicle Create====
<pre>模型:
[on] vehicle create
[on] creat(e|ing|ion of) [a] vehicle
加入的版本:
1.0
当一个载具被创建.</pre>
====On Vehicle Damage====
<pre>模型:
[on] vehicle damage
[on] damag(e|ing) [a] vehicle
加入的版本:
1.0
载具被攻击</pre>
====On Vehicle Destroy====
<pre>模型:
[on] vehicle destroy
[on] destr(oy[ing]|uction of) [a] vehicle
加入的版本:
1.0
载具被摧毁</pre>
====On Vehicle Enter====
<pre>模型:
[on] vehicle enter
[on] enter[ing] [a] vehicle
加入的版本:
1.0
实体进入载具</pre>
====On Vehicle Exit====
<pre>模型:
[on] vehicle exit
[on] exit[ing] [a] vehicle
加入的版本:
1.0
实体离开载具</pre>
====On Weather Change====
<pre>模型:
[on] weather change [to %weather types%]
加入的版本:
1.0
一个世界的天气被切换
示例:
on weather change
on weather change to sunny</pre>
====On World Init====
<pre>模型:
[on] world init
加入的版本:
1.0
一个新的世界被创建</pre>
====On World Load====
<pre>模型:
[on] world load[ing]
加入的版本:
1.0
世界被加载</pre>
====On World Save====
<pre>模型:
[on] world sav(e|ing)
加入的版本:
1.0
世界被存储</pre>
====On World Unload====
<pre>模型:
[on] world unload[ing]
加入的版本:
1.0
世界被卸载</pre>
====On Zombie Break Door====
<pre>模型:
[on] zombie break[ing] [a] [wood[en]] door
加入的版本:
unknown
僵尸破坏门</pre>
====Periodical====
<pre>模型:
every %time span% in [world[s]] %worlds%
加入的版本:
1.0
每隔一定的现实时间
示例:
every second
every minecraft hour
every tick # 警告:卡的一比
every minecraft day in "world"</pre>

===条件===
====Can Build====
<pre>模型:
不能直接使用
加入的版本:
2.0
检测玩家是否可以在区域中放置方块，需要一个区域插件
示例:
command /setblock <material>:
	description: set the block at your crosshair to a different type
	trigger:
		player cannot build at the targeted block:
			message "You do not have permission to change blocks there!"
			stop
		set the targeted block to argument</pre>

====Can Hold====
<pre>模型:
%inventories% (can hold|ha(s|ve) [enough] space (for|to hold)) %item types%
%inventories% (can(no|')t hold|(ha(s|ve) not|ha(s|ve)n't|do[es]n't have) [enough] space (for|to hold)) %item types%
加入的版本:
1.0
检测玩家的背包或箱子是否有足够的空间
示例:
block can hold 200 cobblestone
player has enough space for 64 feathers</pre>
====Chance====
<pre>模型:
chance of %number%[\%]
加入的版本:
1.0
脚本成功或失败的几率
示例:
chance of 50%:
	drop a diamond
chance of {var}% # {var} between 0 and 100
chance of {var} # {var} between 0 and 1</pre>
====Comparison====
<pre>模型:
[neither] %objects% ((is|are) ((greater|more|higher|bigger|larger) than|above)|>) %objects%
[neither](neither)|isn't|aren't) ((less|smaller) than|below)|>=) %objects%
[neither] %objects% ((is|are) ((less|smaller) than|below)|<) %objects%
[neither](neither)|isn't|aren't) ((greater|more|higher|bigger|larger) than|above)|<=) %objects%
[neither](neither)|isn't|aren't|!=) [equal to] %objects%
[neither] %objects% (is|are|=) [(equal to|the same as)] %objects%
[neither] %objects% (is|are) between %objects% and %objects%
[neither](is not|are not|isn't|aren't) between %objects% and %objects%
加入的版本:
1.0
非常常规的脚本，比较两量关系。通常你可以使用平等(如 block is/isn't of <type>), 但一些值可以使用更多/更少。
在这种情况下，你也可以测试一个对象是否在两个其他量之中。
注意：这只是一些形式。事实上，另外两套类似的模式，但（was|were）或将代替（is|are）分别检测不同时间状态的表达。

示例:
the clicked block is a stone slab or a double stone slab
time in the player's world is greater than 8:00
the creature is not an enderman or an ender dragon</pre>
====Contains====
<pre>模型:
%inventories% ha(s|ve) %item types% [in [(the[ir]|his|her|its)] inventory]
%inventories/texts/objects% contain[s] %item types/texts/objects%
%inventories% do[es](n't| not) have %item types% [in [(the[ir]|his|her|its)] inventory]
%inventories/texts/objects% do[es](n't| not) contain %item types/texts/objects%
加入的版本:
1.0
检查有无物品，一段对话有无一些字，或列出变量表是否包含某变量。
示例:
block contains 20 cobblestone
player has 4 flint and 2 iron ingots</pre>
====Damage Cause====
<pre>模型:
[the] damage [(n('|o)]t) [been] (caused|done|made) by %damage cause%
加入的版本:
2.0
检查是什么造成的伤害，来源可以查看变量表。
示例:
# make players use their potions of fire resistance whenever they take any kind of fire damage
on damage:
	damage was caused by lava, fire or burning
	victim is a player
	victim has a potion of fire resistance
	cancel event
	apply fire resistance to the victim for 30 seconds
	remove 1 potion of fire resistance from the victim
# prevent mobs from dropping items under certain circumstances
on death;
	entity is not a player
	damage wasn't caused by a block explosion, an attack, a projectile, a potion, fire, burning, thorns or poison
	clear drops</pre>
====Exists/Is Set====
<pre>模型:
%~objects% (exist[s]|(is|are) set)
%~objects% (do[es](n't| not) exist|(is|are)(n't| not) set)
加入的版本:
1.2
检查一个表达式是否被创建
示例:
{teamscript.%player%.preferred team} is not set
on damage:
	projectile exists
	broadcast "%attacker% used a %projectile% to attack %victim%!"</pre>
====Has Permission====
<pre>模型:
[%players/console%] (do[es]n't|don't|do[es] not) have [the] permission[s] %texts%
[%players/console%] ha(s|ve) [the] permission[s] %texts%
加入的版本:
1.0
检查玩家有无权限
示例:
player has permission "skript.tree"
victim has the permission "admin":
	send "You're attacking an admin!" to attacker</pre>
====Has Played Before====
<pre>模型:
%offline player% [(has|did)] [already] play[ed] [on (this|the) server] (before|already)
%offline player% (has not|hasn't|did not|didn't) [(already|yet)] play[ed] [on (this|the) server] (before|already|yet)
加入的版本:
1.4
检查玩家之前是否玩过游戏
示例:
player has played on this server before
player hasn't played before</pre>
====Is Alive====
<pre>模型:
%living entities% (alive|dead)
%living entities% (alive|dead)
加入的版本:
2.0
检查实体是否存活
示例:
{villagerbuddy.%player%} is dead</pre>
====Is Banned====
<pre>模型:
%offline players/texts% (is|are) banned
%players/texts% [(is|are) IP(-| )]banned
%offline players/texts% (isn't|is not|aren't|are not) banned
%players/texts% [(isn't|is not|aren't|are not) IP(-| )]banned
加入的版本:
1.4
检查一个玩家或IP是否被BAN掉
示例:
player is banned
victim is not IP-banned
"127.0.0.1" is banned</pre>
====Is Blocking====
<pre>模型:
%players% (is|are) (blocking|defending)
%players% (isn't|is not|aren't|are not) (blocking|defending)
加入的版本:
unknown
检查玩家是否在格挡
示例:
victim is blocking</pre>
====Is Burning====
<pre>模型:
%entities% (is|are) (burning|ignited|on fire)
%entities% (isn't|is not|aren't|are not) (burning|ignited|on fire)
加入的版本:
1.4.4
检查实体是否在燃烧
示例:
# increased attack against buring targets
victim is burning:
	increase damage by 2</pre>
====Is Empty====
<pre>模型:
%inventories/slots/texts% (is|are) empty
%inventories/slots/texts% (isn't|is not|aren't|are not) empty
加入的版本:
unknown
检查物品栏/装备栏/文本是空的
示例:
player's inventory is empty</pre>
====Is Enchanted====
<pre>模型:
%item types% (is|are) enchanted [with %enchantment type%]
%item types% (isn't|is not|aren't|are not) enchanted [with %enchantment type%]
加入的版本:
1.4.6
检查物品有无附魔
示例:
tool of the player is enchanted with efficiency 2
helm, chestplate, leggings or boots are enchanted</pre>
====Is Flying====
<pre>模型:
%players% (is|are) flying
%players% (isn't|is not|aren't|are not) flying
加入的版本:
1.4.4
检查玩家飞行
示例:
player is not flying</pre>
====Is Holding====
<pre>模型:
[%living entities%] ha(s|ve) %item types% in hand
[%living entities%] (is|are) holding %item types%
[%living entities%] (ha(s|ve) not|do[es]n't have) %item types% in hand
[%living entities%] (is not|isn't) holding %item types%
加入的版本:
1.0
检查玩家是否持有特定物品。不能在末影人上使用，请使用'entity is [not] an enderman holding <item type>'
示例:
player is holding a stick
victim isn't holding a sword of sharpness</pre>
====Is in World====
<pre>模型:
%entities% (is|are) in [[the] world[s]] %worlds%
%entities% (is not|isn't|are not|aren't) in [[the] world[s]] %worlds%
加入的版本:
1.4
检查玩家是否在世界里
示例:
player is in "world"
argument isn't in world "world_nether"
the attacker is in the world of the victim</pre>
====Is Member/Owner of Region====
<pre>模型:
不能直接使用
加入的版本:
2.1
检查玩家是否为这个区域的成员或主人，需要一个区域插件。
示例:
on region enter:
	player is the owner of the region
	message "Welcome back to %region%!"
	send "%player% just entered %region%!" to all members of the region</pre>
====Is of Type====
<pre>模型:
%item stacks/entities% (is|are) of type[s] %item types/entity types%
%item stacks/entities% (isn't|is not|aren't|are not) of type[s] %item types/entity types%
加入的版本:
1.4
检查物品或实体是否为给定的类型。这经常对变量很有效，你也可以用is来代替。(如. 'victim is a creeper').
示例:
tool is of type {*selected type}
victim is of type {villager type}</pre>
====Is Online====
<pre>模型:
%offline players% ((is|are) online|(is not|isn't|are not|aren't) offline)
%offline players% ((is|are) offline|(is not|isn't|are not|aren't) online)
加入的版本:
1.4
检查玩家是否在线
示例:
player is online
player-argument is offline</pre>
====Is Poisoned====
<pre>模型:
%living entities% (is|are) poisoned
%living entities% (isn't|is not|aren't|are not) poisoned
加入的版本:
1.4.4
检测实体是否中毒
示例:
player is poisoned:
	cure the player from posion
	message "You have been cured!"</pre>
====Is Riding====
<pre>模型:
%entities% (is|are) riding [%entity types%]
%entities% (isn't|is not|aren't|are not) riding [%entity types%]
加入的版本:
2.0
检查实体有无骑着其他实体
示例:
player is riding a saddled pig</pre>
====Is Sleeping====
<pre>模型:
%players% (is|are) sleeping
%players% (isn't|is not|aren't|are not) sleeping
加入的版本:
1.4.4
检查玩家是否在睡觉
示例:
# cut your enemies' throats in their sleep >=)
on attack:
	attacker is holding a sword
	victim is sleeping
	increase the damage by 1000</pre>
====Is Sneaking====
<pre>模型:
%players% (is|are) sneaking
%players% (isn't|is not|aren't|are not) sneaking
加入的版本:
1.4.4
检测玩家是否在潜行
示例:
# prevent mobs from seeing sneaking players if they are at least 4 meters apart
on target:
	target is sneaking
	distance of target and the entity is bigger than 4
	cancel the event</pre>
====Is Sprinting====
<pre>模型:
%players% (is|are) sprinting
%players% (isn't|is not|aren't|are not) sprinting
加入的版本:
1.4.4
检查玩家是否在疾跑
示例:
player is not sprinting</pre>
====Is Wearing====
<pre>模型:
%living entities% (is|are) wearing %item types%
%living entities% (isn't|is not|aren't|are not) wearing %item types%
加入的版本:
1.0
Checks whether a player is wearing some armour.
示例:
player is wearing an iron chestplate and iron leggings
player is wearing all diamond armour</pre>
====PvP====
<pre>模型:
(is PvP|PvP is) enabled [in %worlds%]
(is PvP|PvP is) disabled [in %worlds%]
加入的版本:
1.3.4
检查PVP状态
示例:
PvP is enabled
PvP is disabled in "world"</pre>
====Region Contains====
<pre>模型:
不能直接使用
加入的版本:
2.1
区域中有XXX，必须有区域插件
示例:
player is in the region {regions::3}
on region enter:
	region contains {flags.%world%.red}
	message "The red flag is near!"</pre>
====Time====
<pre>模型:
%date% (was|were)( more|(n't| not) less) than %time span% [ago]
%date% (was|were)((n't| not) more| less) than %time span% [ago]
加入的版本:
2.0
给予变量时间
示例:
command /command_with_cooldown:
	trigger:
		{command.%player%.lastused} was less than a minute ago:
			message "Please wait a minute between uses of this command."
			stop
		set {command.%player%.lastused} to now
		# ... actual command trigger here ...</pre>
====Weather====
<pre>模型:
is %weather types% [in %worlds%]
加入的版本:
1.0
检查世界的天气
示例:
is thundering
is raining in "world" or "world2"</pre>

===效果===
====Ban====
<pre>模型:
ban %texts/offline players% [(by reason of|because [of]|on account of|due to) %text%]
unban %texts/offline players%
ban %players% by IP [(by reason of|because [of]|on account of|due to) %text%]
unban %players% by IP
IP(-| )ban %players% [(by reason of|because [of]|on account of|due to) %text%]
(IP(-| )unban|un[-]IP[-]ban) %players%
加入的版本:
1.4, 2.1.1 (ban reason)
BAN掉玩家或IP
必须满足Skript 2.1.1及Bukkit 172 R0.4以上，可以使用原因来ban出玩家。
如果是一个不支持的原因[如没有创建的变量]，玩家仍旧会被BAN，但会使用默认原因。
示例:
unban player
ban "127.0.0.1"
IP-ban the player because "he is an idiot"</pre>
====Broadcast====
<pre>模型:
broadcast %texts% [(to|in) %worlds%]
加入的版本:
1.0
在服务器公告内容
示例:
broadcast "Welcome %player% to the server!"
broadcast "Woah! It's a message!"</pre>
====Cancel Event====
<pre>模型:
cancel [the] event
uncancel [the] event
加入的版本:
1.0
取消事件的发生
示例:
on damage:
	victim is a player
	victim has the permission "skript.god"
	cancel the event</pre>
====Change: Set/Add/Remove/Delete/Reset====
<pre>模型:
(add|give) %objects% to %~objects%
increase %~objects% by %objects%
give %~objects% %objects%
set %~objects% to %objects%
remove (all|every) %objects% from %~objects%
(remove|subtract) %objects% from %~objects%
reduce %~objects% by %objects%
(delete|clear) %~objects%
reset %~objects%
加入的版本:
1.0 (set, add, remove, delete), 2.0 (remove all)
改变表达式，非常常规的效果
示例:
# set:
Set the player's display name to "<red>%name of player%"
set the block above the victim to lava
# add:
add 2 to the player's health # preferably use '<a href='#heal'>heal</a>' for this
add argument to {blacklist::*}
give a diamond pickaxe of efficiency 5 to the player
increase the data value of the clicked block by 1
# remove:
remove 2 pickaxes from the victim
subtract 2.5 from {points.%player%}
# remove all:
remove every iron tool from the player
remove all minecarts from {entitylist::*}
# delete:
delete the block below the player
clear drops
delete {variable}
# reset:
reset walk speed of player
reset chunk at the targeted block</pre>
====Colour Armour====
<pre>模型:
(dye|colo[u]r|paint) %slots/item stack% %color%
(dye|colo[u]r|paint) %slots/item stack% (%number%, %number%, %number%)
加入的版本:
2.0
给当前装备染色，你可以使用RGB代码。
示例:
dye player's helmet blue
colour the player's tool red</pre>
====Command====
<pre>模型:
[execute] [the] command %texts% [by %players/console%]
[execute] [the] %players/console% command %texts%
(let|make) %players/console% execute [[the] command] %texts%
加入的版本:
1.0
使用指令
示例:
make player execute command "/suicide"
execute console command "/say Hello everyone!"</pre>
====Damage/Heal/Repair====
<pre>模型:
damage %slots/living entities/item stack% by %number% [heart[s]]
heal %living entities% [by %number% [heart[s]]]
repair %slots/item stack% [by %number%]
加入的版本:
1.0
攻击/治疗/修复
示例:
damage player by 5 hearts
heal the player
repair tool of player</pre>
====Delay====
<pre>模型:
(wait|halt) [for] %time span%
加入的版本:
1.4
等待一定的事件，不能作为tempban使用
示例:
wait 2 minutes
halt for 5 minecraft hours
wait a tick</pre>
====Drop====
<pre>模型:
drop %item types/experience point% [%directions% %locations%]
加入的版本:
1.0
掉落一个或多个物品
示例:
on death of creeper:
	drop 1 TNT</pre>
====Enchant/Disenchant====
<pre>模型:
enchant %~item stack% with %enchantment types%
disenchant %~item stack%
加入的版本:
2.0
给物品附魔或解除附魔
示例:
enchant the player's tool with sharpness 5
disenchant the player's tool</pre>
====Equip====
<pre>模型:
equip [%living entity%] with %item types%
make %living entity% wear %item types%
加入的版本:
1.0
给玩家穿戴装备，会覆盖当前装备。
Skript 2.1 起怪物也能穿戴装备了，猪可以穿戴鞍，马可以穿戴鞍，马铠和箱子。
示例:
equip player with diamond helmet
equip player with all diamond armour
equip the clicked horse with diamond horse armour and a saddle
make the last spawned pig wear a saddle</pre>
====Exit====
<pre>模型:
(exit|stop) [trigger]
(section|loop|conditional)
(section|loop|conditional)s
(section|loop|conditional)s
加入的版本:
unknown
停止循环的触发器
示例:
if player has any ore:
	stop
message "%player% has no ores!"
loop blocks above the player:
	loop-block is not air:
		exit 2 sections
	set loop-block to water</pre>
====Explosion====
<pre>模型:
[(create|make)] [an] explosion (of|with) (force|strength|power) %number% [%directions% %locations%]
[(create|make)] [a] safe explosion (of|with) (force|strength|power) %number% [%directions% %locations%]
[(create|make)] [a] fake explosion [%directions% %locations%]
[(create|make)] [an] explosion[ ]effect [%directions% %locations%]
加入的版本:
1.0
用给出的力量制造爆炸。 
力量是0时可以制造一场假爆炸，如第三行。 
从 Bukkit 1.4.5 / Skript 2.0 开始你可以使用第二行，即安全爆炸，不会破坏方块。
示例:
create an explosion of force 10 at the player
create a fake explosion at the victim</pre>
====Ignite/Extinguish====
<pre>模型:
(ignite|set fire to) %entities% [for %time span%]
(set|light) %entities% on fire [for %time span%]
extinguish %entities%
加入的版本:
1.4
在实体上制造火焰/打雷
示例:
ignite the player
extinguish the player</pre>
====Kick====
<pre>模型:
kick %players% [(by reason of|because [of]|on account of|due to) %text%]
加入的版本:
1.0
把玩家从服务器踢出
示例:
on place of TNT, lava, or obsidian:
	kick the player due to "You may not place %block%!"
	cancel the event</pre>
====Kill====
<pre>模型:
kill %entities%
加入的版本:
1.0
击杀一个或多个实体。
注意: 这个效果不是把实体的生命设置为0，并不会触发死亡消息，而且不会掉落物品，而是用它最大生命的100倍去伤害它。
示例:
kill the player
kill all creepers in the player's world
kill all endermen, witches and bats</pre>
====Lightning====
<pre>模型:
[[ ]effect] %directions% %locations%
加入的版本:
1.4
在位置生成一道闪电
示例:
strike lightning at the player
strike lightning effect at the victim</pre>
====Log====
<pre>模型:
log %texts% [(to|in) [file[s]] %texts%]
加入的版本:
2.0
写一个log文件。你可以在 /plugins/Skript/logs 里找到
使用 'server.log' 将如此记录 '[Skript] [<script>.sk] <message>'
示例:
on place of TNT:
	log "%player% placed TNT in %world% at %location of block%" to "tnt/placement.log"</pre>
====Message====
<pre>模型:
(message|send [message]) %texts% [to %players/console%]
加入的版本:
1.0
发送消息
示例:
message "A wild %player% appeared!"
message "This message is a distraction. Mwahaha!"
send "Your kill streak is %{kill streak.%player%}%." to player
if the targeted entity exists:
	message "You're currently looking at a %type of the targeted entity%!"</pre>
====op/deop====
<pre>模型:
[de[-]]op %offline players%
加入的版本:
1.0
给予/拿走玩家的OP权限
示例:
op the player
deop all players</pre>
====Open Inventory====
<pre>模型:
[(open|show) ((crafting [table]|workbench) (view|window|inventory)]|%inventory%) (to|for) %players%
close [the] inventory [view] (to|of|for) %players%
close %players%'[s] inventory [view]
加入的版本:
2.0, 2.1.1 (closing)
为玩家打开背包
SHOW为不能移动东西
OPEN为可以移动
示例:
show the victim's inventory to the player
open the player's inventory for the player
close the player's inventory</pre>
====Play Effect====
<pre>模型:
(play|show) %visual effects% (on|%directions%) %entities/locations% [to %players%]
加入的版本:
2.1
播放声音
示例:
play wolf hearts on the clicked wolf
show mob spawner flames at the targeted block to the player</pre>
====Poison/Cure====
<pre>模型:
poison %living entities% [for %time span%]
(cure|unpoison) %living entities% [(from|of) poison]
加入的版本:
1.3.2
中毒
示例:
poison the player
poison the victim for 20 seconds
cure the player from poison</pre>
====Potion Effects====
<pre>模型:
apply [potion of] %potions% [potion] [[[of] tier] %number%] to %living entities% [for %time span%]
加入的版本:
2.0
药水效果
示例:
apply swiftness 2 to the player
remove haste from the victim
on join:
	apply potion of strength of tier {strength.%player%} to the player for 999 days</pre>
====Push====
<pre>模型:
(push|thrust) %entities% %direction% [(at|with) (speed|velocity|force) %number%]
加入的版本:
1.4.6
推开实体
示例:
push the player upwards
push the victim downwards at speed 0.5</pre>
====PvP====
<pre>模型:
enable PvP [in %worlds%]
disable PVP [in %worlds%]
加入的版本:
1.3.4
检测PVP状态
示例:
enable PvP #(current world only)
disable PvP in all worlds</pre>
====Replace====
<pre>模型:
replace [(all|every)] %texts% in %text% with %text%
replace [(all|every)] %texts% with %text% in %text%
加入的版本:
2.0
把一些文本替换
示例:
replace "<item>" in {textvar} with "%tool of player%"
replace every "&" with "§" in line 1
# The following acts as a simple chat censor, but it will e.g. censor mass, hassle, assassin, etc. as well:
on chat:
	replace all "f[u]c[k"<ref>这是译者为了过审而加的</ref>, "b[i]t]c][h" and "a[s]s" with "****" in the message</pre>
====Shear====
<pre>模型:
shear %living entities%
un[-]shear %living entities%
加入的版本:
2.0
为羊剪羊毛，请注意不会掉落物品
示例:
on rightclick on a sheep holding a sword:
	shear the clicked sheep</pre>
====Shoot====
<pre>模型:
shoot %entity types% [from %living entities/locations%] [(at|with) (speed|velocity) %number%] [%direction%]
(make|let) %living entities/locations% shoot %entity types% [(at|with) (speed|velocity) %number%] [%direction%]
加入的版本:
1.4
从实体身上发射物品
示例:
shoot an arrow
make the player shoot a creeper at speed 10
shoot a pig from the creeper</pre>
====Spawn====
<pre>模型:
spawn %entity types% [%directions% %locations%]
spawn %number% of %entity types% [%directions% %locations%]
加入的版本:
1.0
召唤一个实体
示例:
spawn 3 creepers at the targeted block
spawn a ghast 5 meters above the player</pre>
====Teleport====
<pre>模型:
teleport %entities% (to|%direction%) %location%
加入的版本:
1.0
传送实体到某个位置
示例:
teleport the player to {homes.%player%}
teleport the attacker to the victim</pre>
====Toggle====
<pre>模型:
(close|turn off|de[-]activate) %blocks%
(toggle|switch) [[the] state of] %blocks%
(open|turn on|activate) %blocks%
加入的版本:
1.4
切换某个方块的状态，如开门
示例:
# use arrows to toggle levers, doors, etc.
on projectile hit:
    projectile is arrow
    toggle the block at the arrow</pre>
====Tree====
<pre>模型:
(grow|create|generate) tree [of type %tree type%] %directions% %locations%
(grow|create|generate) %tree type% [tree] %directions% %locations%
加入的版本:
1.0
生成树，需要有足够空间
示例:
grow a tall redwood tree above the clicked block</pre>
====Vehicle====
<pre>模型:
(make|let|force) %entities% [to] (ride|mount) [(in|on)] %entity/entity types%
[(make|let|force) %entities% [to] (dismount|(dismount|leave) (from|of)] [(any|the[ir]|his|her)] vehicle[s])
[(eject|dismount) (any|the)] passenger[s] (of|from) %entities%
加入的版本:
2.0
使实体坐上载具。
示例:
make the player ride a saddled pig
make the attacker ride the victim
</pre>

===Expressions===
Expressions are syntax elements that represent a certain object, e.g. a player or a number, or multiple objects, e.g. the server's worlds or a list of blocks. Expressions can be used anywhere where Skript expects a value, e.g. in set {var} to <value> or teleport <entity expression> to <location expression>. The other possibility for values is to use a static value, e.g. ‘6’ or ‘a pickaxe and a shovel’.

There are basically two kinds of expressions:
simple expressions, which are usually one or a few words like ‘player’, ‘world’, or ‘last spawned entity’, and are usually event-dependent, i.e. their value will change depending on the event. The ‘player’ expression for example will hold the current event's player, which depends on which player triggered the event.
property expressions, which get a value from another expression, e.g. data value of <item>, altitude of <location>, or <entity>'s world.
There are a few exceptions though, e.g. distance between <location> and <location> or the direction expression.

Expressions that represent multiple values can be looped to execute some code for each element of the expression with loop <expression>:. Please refer to the loops page for more information.
====Advanced====
Starting with Skript 2.0, expressions can be grouped with parentheses to denote their relation, e.g. set {var} to 10 emeralds and an apple or 5 stone is ambiguous while set {var} to 10 emeralds and (an apple or 5 stone) is not (this particular example will even result in a warning if no brackets are used).
You should also use brackets when using lists of expressions inside other expressions, e.g. all players in "world" and "world_nether" should be written as all players in ("world" and "world_nether"), as otherwise it might be parsed as (all players in "world") and ("world_nether").
====Altitude====
<pre>模型:
[the] altitude[s] of %locations%
%locations%'[s] altitude[s]
加入的版本:
1.4.3
Effectively an alias of 'y-coordinate of …', it represents the height of some object above bedrock.
示例:
on damage:
	altitude of the attacker is higher that the altitude of the victim
	set damage to damage * 1.25</pre>

====Amount====
<pre>模型:
(amount|number|size) of %objects%
加入的版本:
1.0
The amount of something.
Please note that amount of <items> will not return the number of items, but the number of stacks, e.g. 1 for a stack of 64 torches.
示例:
message "There are %number of all players% players online!"</pre>
====Amount of Items====
<pre>模型:
[the] (amount|number) of %item types% (in|of) %inventories%
加入的版本:
2.0
Counts how many of a particular item type are in a given inventory.
示例:
message "You have %number of ores in the player's inventory% ores in your inventory."</pre>
====Argument====
<pre>模型:
[the] last arg[ument][s]
[the] arg[ument][s](-| )<(d+)>
[the] <(d*1)st|(d*2)nd|(d*3)rd|(d*[4-90])th> arg[ument][s]
[the] arg[ument][s]
[the] %*type%( |-)arg[ument][( |-)<d+>]
[the] arg[ument]( |-)%*type%[( |-)<d+>]
加入的版本:
1.0
Only available in command events. Holds the value of the nth argument given to the command, e.g. if the command "/tell " is used like "/tell Njol Hello Njol!", argument 1 is the player named "Njol" and argument 2 is "Hello Njol!". 
One can also use the type of the argument instead of its index to address the argument, e.g. in the above example 'player-argument' is the same as 'argument 1'.
示例:
give the item-argument to the player-argument
damage the player-argument by the number-argument
give a diamond pickaxe to the argument
add argument 1 to argument 2
heal the last argument</pre>
====Arithmetic====
<pre>模型:
%number%[ ]+[ ]%number%
%number%[ ]-[ ]%number%
%number%[ ]*[ ]%number%
%number%[ ]/[ ]%number%
%number%[ ]^[ ]%number%
加入的版本:
1.4.2
Arithmetic expressions, e.g. 1+2, (2 - health of player)/3, etc. 
Available operands are addition (+), subtraction (-), multiplication (*), division (/), and exponentiation (^). Negation is not available yet, use 0 - expr instead.
示例:
set the player's health to 10 - the player's health
loop (argument + 2)/5 times:
	message "Two useless numbers: %loop-num*2 - 5%, %2^loop-num - 1%"
message "You have %health of player * 2% half hearts of HP!"</pre>
====Armour Slot====
<pre>模型:
[the] (boot[s]|shoe[s]|leg[ging][s]|chestplate[s]|helm[et][s]) [slot] of %living entities%
%living entities%'[s] (boot[s]|shoe[s]|leg[ging][s]|chestplate[s]|helm[et][s]) [slot]
加入的版本:
1.0
A part of a player's armour, i.e. the boots, leggings, chestplate or helmet. 
As of Skript 2.1 this expression can be used for mobs as well, e.g. to equip zombies with armour.
示例:
set chestplate of the player to a diamond chestplate
helmet of player is neither a helmet nor air # player is wearing a block, e.g. from another plugin</pre>
====Attacked====
<pre>模型:
[the] (attacked|damaged|victim) [<(.+)>]
加入的版本:
1.3
The victim of a damage event, e.g. when a player attacks a zombie this expression represents the zombie.
示例:
on damage:
	victim is a creeper
	damage the attacked creeper by 1 heart</pre>
====Attacker====
<pre>模型:
[the] (attacker|damager)
加入的版本:
1.3
The attacker of a damage event, e.g. when a player attacks a zombie this expression represents the player.
Please note that the attacker can also be a block, e.g. a cactus or lava, but this expression will not be set in these cases.
示例:
on damage:
	attacker is a player
	health of attacker is less than or equal to 2
	damage victim by 1 heart</pre>
====Bed====
<pre>模型:
[the] bed[s] [location[s]] of %players%
%players%'[s] bed[s] [location[s]]
加入的版本:
2.0
The bed location of a player, i.e. the spawn point of a player if he ever slept in a bed and the bed still exists and is unobstructed.
示例:
bed of player exists:
	teleport player the the player's bed
else:
	teleport the player to the world's spawn point</pre>
====Biome====
<pre>模型:
[the] biome (of|%direction%) %location%
%location%'[s] biome
加入的版本:
1.4.4
The biome at a certain location. Please note that biomes are only defined for x/z-columns, i.e. the altitude (y-coordinate) doesn't matter.
示例:
# damage player in deserts constantly
every real second:
	loop all players:
		biome at loop-player is desert
		damage the loop-player by 1</pre>
====Block====
<pre>模型:
[the] [event-]block
[the] block %direction% [%location%]
加入的版本:
1.0
The block involved in an event, e.g. the clicked block or the placed block. 
Can optionally include a direction as well, e.g. 'block above' or 'block in front of the player'.
示例:
block is ore
set block below to air
spawn a creeper above the block
loop blocks in radius 4:
	loop-block is obsidian
	set loop-block to water
block is a chest:
	clear the inventory of the block</pre>
====Block Sphere====
<pre>模型:
[(all|the)] blocks in radius %number% [(of|around) %location%]
[(all|the)] blocks around %location% in radius %number%
加入的版本:
1.0
All blocks in a sphere around a center, mostly useful for looping.
示例:
loop blocks in radius 5 around the player:
	set loop-block to air
set all blocks in radius 5 around the player to air</pre>
====Blocks====
<pre>模型:
[the] blocks %direction% [%locations%]
[the] blocks from %location% [on] %direction%
[the] blocks from %block% to %block%
[the] blocks between %block% and %block%
加入的版本:
1.0
Blocks relative to other blocks or between other blocks. Can be used to get blocks relative to other blocks or for looping.
示例:
loop blocks above the player:
loop blocks between the block below the player and the targeted block:
set the blocks below (the player, the victim and the targeted block) to air</pre>
====Blocks in Region====
<pre>模型:
cannot be used directly
加入的版本:
2.1
All blocks in a region.
This expression requires a supported regions plugin to be installed.
示例:
loop all blocks in the region {arena.%{faction.%player%}%}:
	clear the loop-block</pre>
====Chunk====
<pre>模型:
[the] chunk[s] (of|%directions%) %locations%
%locations%'[s] chunk[s]
加入的版本:
2.0
The chunk a block, location or entity is in.
示例:
add the chunk at the player to {protected chunks::*}</pre>
====Clicked Block/Entity====
<pre>模型:
[the] clicked (block|%*item type/entity type%)
加入的版本:
1.0
Only available in click events: Represents the clicked block or entity.
示例:
message "You clicked on a %type of clicked entity%!"
clicked block is a chest:
	show the inventory of the clicked block to the player</pre>
====Colour of====
<pre>模型:
[the] colo[u]r[s] of %item stacks/entities%
%item stacks/entities%'[s] colo[u]r[s]
加入的版本:
1.2
The colour of an item, can also be used to colour chat messages with "<%colour of ...%>this text is coloured!".
示例:
on click on wool:
	message "This wool block is <%colour of block%>%colour of block%<reset>!"
	set the colour of the block to black</pre>
====Coloured / Uncoloured====
<pre>模型:
(colo[u]r-|colo[u]red )%texts%
(un|non)[-](colo[u]r-|colo[u]red )%texts%
加入的版本:
2.0
Parses <colour>s (including chat styles) in a message or removes any colours & chat styles from the message.
This expression replaces localised colours & chat styles, i.e. it doesn't replace english ones, which makes it appropriate to colour command arguments and chat messages.
示例:
on chat:
	set message to coloured message
command /fade <player>:
	trigger:
		set display name of the player-argument to uncoloured display name of the player-argument</pre>
====Command====
<pre>模型:
[the] (full|complete|whole) command
[the] command [label]
[the] arguments
加入的版本:
2.0
The command that caused an 'on command' event (excluding the leading slash and all arguments). 
Use 'full command' for the command including arguments, or 'arguments' for the arguments only. 
Please note that this event is not adequate for creating custom commands. See the article on custom commands to find out how to define new commands.
示例:
# prevent any commands except for the /exit command during some game
on command:
	{game.%player%.is playing} is true
	command is not "exit"
	message "You're not allowed to use commands during the game"
	cancel the event</pre>
====Command Sender====
<pre>模型:
[the] [command['s]] (sender|executor)
加入的版本:
2.0
The player or the console who sent a command. Mostly useful in commands and command events.
示例:
make the command sender execute "/say hi!"
on command:
	log "%executor% used command /%command% %arguments%" to "commands.log"</pre>
====Compass Target====
<pre>模型:
[the] compass target of %players%
%players%'[s] compass target
加入的版本:
2.0
The location a player's compass is pointing at. 
Please note that wile you can set a player's compass target to an entity, it will actually be set to the location of the entity at the time when the effect is executed, and thus the compass won't automatically follow the entity.
示例:
# make all player's compasses target a player stored in {compass target.%player%}
every 5 seconds:
	loop all players:
		set the loop-player's compass target to location of {compass target.%loop-player%}</pre>
====Console====
<pre>模型:
[the] (console|server)
加入的版本:
1.3.1
Represents the server's console which can receive messages and execute commands.
示例:
execute console command "/stop"
send "message to console" to the console</pre>
====Coordinate====
<pre>模型:
[the] (x|y|z)(-| )(coord[inate]|pos[ition]|loc[ation])[s] of %locations%
%locations%'[s] (x|y|z)(-| )(coord[inate]|pos[ition]|loc[ation])[s]
加入的版本:
1.4.3
Represents a given coordinate of a location.
示例:
player's y-coordinate is smaller than 40:
	message "Watch out for lava!"</pre>
====Creature/Entity/Player/Projectile/Villager/Powered Creeper/etc.====
<pre>模型:
[the] [event-]<.+>
加入的版本:
1.0
The entity involved in an event (an entity is a player, a creature or an inanimate object like ignited TNT, a dropped item or an arrow).
You can use the specific type of the entity that's involved in the event, e.g. in a 'death of a creeper' event you can use 'the creeper' instead of 'the entity'.
示例:
give a diamond sword of sharpness 3 to the player
kill the creeper
kill all powered creepers in the wolf's world
projectile is an arrow</pre>
====Damage====
<pre>模型:
[the] damage
加入的版本:
1.3.5
How much damage is done in a damage event, possibly ignoring armour, criticals and/or enchantments. Can be changed (remember that in Skript '1' is one full heart, not half a heart).
示例:
increase the damage by 2</pre>
====Damage Cause====
<pre>模型:
[the] damage (cause|type)
加入的版本:
2.0
The damage cause of a damage event. Please click on the link for more information.
示例:
damage cause is lava, fire or burning</pre>
====Data Value====
<pre>模型:
[the] ((data|damage)[s] [value[s]]|durabilit(y|ies)) of %item stacks/slots%
%item stacks/slots%'[s] ((data|damage)[s] [value[s]]|durabilit(y|ies))
加入的版本:
1.2
The data value of an item.
You usually don't need this expression as you can check and set items with aliases easily, but this expression can e.g. be used to "add 1 to data of <item>", e.g. for cycling through all wool colours.
示例:
add 1 to the data value of the clicked block</pre>
====Difference====
<pre>模型:
difference (between|of) %object% and %object%
加入的版本:
1.4
The difference between two values, e.g. numbers, dates or times. 
Use distance for locations.
示例:
difference between {command.%player%.lastuse} and now is smaller than a minute:
  message "You have to wait a minute before using this command again!"
  stop</pre>
====Direction====
<pre>模型:
[%number% [(north[(east|west)][(south[(east|west)][(east|west)[(above|over|up|down)[ward(below|under[neath]|beneath) [%direction%]
[%number% [[(direction|horizontal direction|facing|horizontal facing) of %entity/block% (of|from)]
[%number% [[(direction|horizontal direction|facing|horizontal facing) (of|from)]
[%number% [(in[ ]front [of]|forward[s]|behind|backwards|right|left) [of])
[%number% [(in[ ]front [of]|forward[s]|behind|backwards|right|left) [of])
加入的版本:
1.0 (basic), 2.0 (extended)
A helper expression for the direction type.
示例:
thrust the player upwards
set the block behind the player to water
loop blocks above the player:
	set {_rand} to a random integer between 1 and 10
	set the block {_rand} meters south east of the loop-block to stone
block in horizontal facing of the clicked entity from the player is air
spawn a creeper 1.5 meters horizontally behind the player
spawn a TNT 5 meters above and 2 meters horizontally behind the player
thrust the last spawned TNT in the horizontal direction of the player with speed 0.2
push the player upwards and horizontally forward at speed 0.5
push the clicked entity in in the direction of the player at speed -0.5
open the inventory of the block 2 blocks below the player to the player
teleport the clicked entity behind the player
grow a regular tree 2 meters horizontally behind the player</pre>
====Distance====
<pre>模型:
[the] distance between %location% and %location%
加入的版本:
1.0
The distance between two points, measured in meters (i.e. blocks). 
Like in other expressions, the location of a block is understood to be at its center, while the location of an entity is usually at its feet.
示例:
distance between the player and {%player%.home} is smaller than 20:
	message "You're very close to your home!"</pre>
====Drops====
<pre>模型:
[the] drops
加入的版本:
1.0
Only available in death events: Represents the drops of the dying creature. 
Drops can be prevented from dropping by removing them with "remove ... from drops", e.g. "remove all pickaxes from the drops", or "clear drops" if you don't want any drops at all.
示例:
clear drops
remove 4 planks from the drops</pre>
====Element of====
<pre>模型:
([the] first|[the] last|[a] random) element [out] of %objects%
加入的版本:
2.0
The first, last or a random element of a set, e.g. a list variable.
See also: random
示例:
give a random element out of {free items::*} to the player</pre>
====Enchantment Level====
<pre>模型:
[the] (%enchantment% level|level of [[the] enchant[ment]] %enchantment%) o(f|n) %item types%
%item types%'[s] (%enchantment% level|level of [[the] enchant[ment]] %enchantment%)
加入的版本:
2.0
The level of a particular enchantment on an item
示例:
player' tool is a sword of sharpness:
	message "You have a sword of sharpness %level of sharpness of the player's tool% equipped"</pre>
====Ender Chest====
<pre>模型:
[the] ender[ ]chest[s] of %players%
%players%'[s] ender[ ]chest[s]
加入的版本:
2.0
The ender chest of a player. This can be used wherever an inventory can be used, in particular its items can be modified, and it can be shown to any player (not only the owning player).
示例:
open the player's ender chest to the player</pre>
====Entities====
<pre>模型:
[all] %*entity types% [(in|of) [world[s]] %worlds%]
[all] entities of type[s] %entity types% [(in|of) [world[s]] %worlds%]
[all] %*entity types% (within|[with]in radius) %number% [(block[s]|met(er|re)[s])] (of|around) %location%
[all] entities of type[s] %entity types% in radius %number% (of|around) %location%
加入的版本:
1.2.1
All entities in all world, in a specific world or in a radius around a certain location, e.g. 'all players', 'all creepers in the player's world', or 'players in radius 100 of the player'.
示例:
kill all creepers in the player's world
send "Psst!" to all players witin 100 meters of the player
give a diamond to all ops
heal all tamed wolves in radius 2000 around {town center}</pre>
====Experience====
<pre>模型:
[the] [(spawned|dropped)] [e]xp[erience] [orb[s]]
加入的版本:
2.1
How much experience was spawned in an experience spawn event. Can be changed.
示例:
on experience spawn:
	add 5 to the spawned experience</pre>
====Facing====
<pre>模型:
[the] [horizontal] facing of %living entities/blocks%
%living entities/blocks%'[s] [horizontal] facing
加入的版本:
1.4
The facing of an entity or block, i.e. exactly north, south, east, west, up or down (unlike direction which is the exact direction, e.g. '0.5 south and 0.7 east')
示例:
# makes a bridge
loop blocks from the block below the player in the horizontal facing of the player:
	set block to cobblestone</pre>
====Food Level====
<pre>模型:
[the] (food|hunger)[[ ](level|met(er|re)|bar)] [of %player%]
%player%'[s] (food|hunger)[[ ](level|met(er|re)|bar)]
加入的版本:
1.0
The food level of a player from 0 to 10. Has several aliases: food/hunger level/meter/bar.
示例:
set the player's food level to 10</pre>
====Former/Future State====
<pre>模型:
[the] (former|past|old) [state] [of] %~object%
%~object% before [the event]
[the] (future|to-be|new) [state] [of] %~object%
%~object%(-to-be| after[(wards| the event)])
加入的版本:
1.1
Represents the value of an expression before an event happened or the value it will have directly after the event, e.g. the old or new level respectively in a level change event.
Note: The past, future and present states of an expression are sometimes called 'time states' of an expression.
Note 2: If you don't specify whether to use the past or future state of an expression that has different values, its default value will be used which is usually the value after the event.
示例:
on teleport:
	former world was "world_nether" # or 'world was'
	world will be "world" # or 'world after the event is'
on tool change:
	past tool is an axe
	the tool after the event will be air
on weather change:
	set {weather.%world%.old} to past weather
	set {weather.%world%.current} to the new weather</pre>
====Furnace Slot====
<pre>模型:
[the] (ore|fuel|result)[s] [slot[s]] of %blocks%
%blocks%'[s] (ore|fuel|result)[s] [slot[s]]
加入的版本:
1.0
A slot of a furnace, i.e. either the ore, fuel or result slot.
Remember to use 'block' and not 'furnace', as 'furnace' is not an existing expression.
示例:
set the fuel slot of the clicked block to a lava bucket
set the block's ore slot to 64 iron ore
give the result of the block to the player
clear the result slot of the block</pre>
====Game Mode====
<pre>模型:
[the] game[ ]mode of %players%
%players%'[s] game[ ]mode
加入的版本:
1.0
The game mode of a player, which can be either survival, creative, or adventure.
示例:
player's gamemode is survival
set the player's gamemode to creative</pre>
====Hash====
<pre>模型:
[md5][( |-)hash(ed|[( |-)]code] of) %texts%
加入的版本:
2.0
Hashes the given text using the MD5 algorithm. This is useful for storing passwords or IP addresses without having to store them literally. 
Please note that an MD5 hash is irreversible, i.e. you won't be able to get the original text back (which is the point of storing passwords like this). Brute force and rainbow table attacks can still be performed on hashes though which can easily crack short or insecure passwords.
示例:
command /setpass <text>:
	trigger:
		set {password.%player%} to hashed text-argument
command /login <text>:
	trigger:
		{password.%player%} is hashed text-argument:
			message "login successful."
		else:
			message "wrong password!"</pre>
====Head location====
<pre>模型:
[the] (head|eye[s]) [location[s]] of %living entities%
%living entities%'[s] (head|eye[s]) [location[s]]
加入的版本:
2.0
The location of an entity's head, mostly useful for players and e.g. looping blocks in the player's line of sight.
Please note that this location is only accurate for entities whose head is exactly above their center, i.e. players, endermen, zombies, skeletons, etc., but not sheep, pigs or cows.
示例:
set the block at the player's head to air
set the block in front of the player's eyes to glass
loop blocks in front of the player's head:</pre>
====Health====
<pre>模型:
[the] health of %living entities%
%living entities%'[s] health
加入的版本:
1.0
The health of a creature, e.g. a player, mob, villager, etc. from 0 to the creature's max health, e.g. 10 for players.
示例:
message "You have %health% HP left."</pre>
====Id====
<pre>模型:
[the] id[s] of %item type%
%item type%'[s] id[s]
加入的版本:
1.0
The id of a specific item. You usually don't need this expression as you can likely do everything with aliases.
示例:
message "the ID of %type of the clicked block% is %id of the clicked block%."</pre>
====Index Of====
<pre>模型:
[the] [(first|last)] index of %text% in %text%
加入的版本:
2.1
The first of last index of a character (or text) in a text, or -1 if it doesn't occur in the text. Indices range from 1 to the length of the text.
示例:
set {_@} to the first index of "@" in the text argument
if {_s} contains "abc":
	set {_s} to the first (index of "abc" in {_s} + 3) characters of {_s} # removes everything after the first "abc" from {_s}</pre>
====Inventory====
<pre>模型:
[the] inventor(y|ies) of %inventoryholders%
%inventoryholders%'[s] inventor(y|ies)
加入的版本:
1.0
The inventory of a block or player. You can usually omit this expression and can directly add or remove items to/from blocks or players.
示例:
add a plank to the player's inventory
clear the player's inventory
remove 5 wool from the inventory of the clicked block</pre>
====IP====
<pre>模型:
IP[s][( |-)address[es]] of %players%
%players%'[s] IP[s][( |-)address[es]]
加入的版本:
1.4
The IP address of a player.
示例:
IP-ban the player # is equal to the next line
ban the IP-address of the player
broadcast "Banned the IP %IP of player%"</pre>
====Item====
<pre>模型:
[the] item
加入的版本:
unknown
The item involved in an event, e.g. in a drop, dispense, pickup or craft event.
示例:
on dispense:
	item is a clock
	set the time to 6:00</pre>
====Items====
<pre>模型:
[(all|every)] item(s|[ ]types)
items of type[s] %item types%
[(all|every)] block(s|[ ]types)
blocks of type[s] %item types%
加入的版本:
unknown
Items or blocks of a specific type, useful for looping.
示例:
loop items of type ore and log:
	block contains loop-item
	message "There's at least one %loop-item% in this block"
	stop loop
drop all blocks at the player # drops one of every block at the player</pre>
====Items In====
<pre>模型:
[all] items (inventor(y|ies)) %inventories%
加入的版本:
2.0
All items in an inventory. Useful for looping or storing in a list variable. 
Please note that the positions of the items in the inventory are not saved, only their order is preserved.
示例:
loop all items in the player's inventory:
	loop-item is enchanted
	remove loop-item from the player
set {inventory.%player%::*} to items in the player's inventory</pre>
====Join & Split====
<pre>模型:
(concat[enate]|join) %texts% [(with|using|by) [[the] delimiter] %text%]
split %text% (at|using|by) [[the] delimiter] %text%
%text% [split] (at|using|by) [[the] delimiter] %text%
加入的版本:
2.1
Joins several texts with a common delimiter (e.g. ", "), or splits a text into multiple texts at a given delimiter.
示例:
message "Online players: %join all players with " | "%" # %all players% would use the default "x, y, and z"
set {_s::} to the string argument split at ","</pre>
====Last Spawned/Shot Entity====
<pre>模型:
[the] [last[ly]] (spawned|shot) %*entity type%
加入的版本:
1.3 (spawned entity), 2.0 (shot entity)
Holds the entity that was spawned most recently with the spawn effect, or shot with the shoot effect. Please note that even though you can spawn multiple mobs simultaneously (e.g. with 'spawn 5 creepers'), only the last spawned mob is saved and can be used. If you spawn an entity and shoot a projectile you can however access both.
示例:
spawn a priest
set {%spawned priest%.healer} to true
shoot an arrow from the last spawned entity
ignite the shot projectile</pre>
====Length====
<pre>模型:
[the] length of %texts%
%texts%'[s] length
加入的版本:
2.1
The length of a text, in number of characters.
示例:
set {_l} to length of the string argument</pre>
====Level====
<pre>模型:
[the] level of %players%
%players%'[s] level
加入的版本:
unknown
The level of a player.
示例:
reduce the victim's level by 1
set the player's level to 0</pre>
====Level Progress====
<pre>模型:
[the] level progress of %players%
%players%'[s] level progress
加入的版本:
2.0
The progress a player has made until the next level. Remember that this value is between 0 and 1, not 0 and 100!
Changing this value can cause a player's level to change if the resulting level progess is negative or larger than 1, e.g.increase the player's level progress by 0.5 will make the player gain a level if his progress was more than 50%.
示例:
# use the exp bar as mana
on rightclick with a blaze rod:
	player's level progress is larger than 0.2
	shoot a fireball from the player
	reduce the player's level progress by 0.2
every 2 seconds:
	loop all players:
		level progress of loop-player is smaller than 0.9:
			increase level progress of the loop-player by 0.1
		else:
			set level progress of the loop-player to 0.99
on xp spawn:
	cancel event</pre>
====Light Level====
<pre>模型:
[(sky|sun|block)[ ]]light[ ]level [(of|%direction%) %location%]
加入的版本:
1.3.4
Gets the light level at a certain location which ranges from 0 to 15.
It can be separated into sunlight (15 = direct sunlight, 1-14 = indirect) and block light (torches, glowstone, etc.). The total light level of a block is the maximum of the two different light types.
示例:
# set vampire players standing in bright sunlight on fire
every 5 seconds:
	loop all players:
		{vampire.%loop-player%} is true
		sunlight level at the loop-player is greater than 10
		ignite the loop-player for 5 seconds</pre>
====Location====
<pre>模型:
[the] [event-](location|position)
[the] (location|position) %direction% [%location%]
加入的版本:
2.0
The location where an event happened (e.g. at an entity or block), or a location relative to another (e.g. 1 meter above another location).
示例:
drop 5 apples at the event-location # exactly the same as writing 'drop 5 apples'
set {_loc} to the location 1 meter above the player</pre>
====Location At====
<pre>模型:
[the] (location|position) [at] [(][x[ ][=[ ]]]%number%, [y[ ][=[ ]]]%number%, [and] [z[ ][=[ ]]]%number%[)] [[(in|of) [[the] world]] %world%]
加入的版本:
2.0
Allows to create a location from three coordinates and a world. 
This expression is currently not parsed correctly, and there is no ETA on a fix yet.
示例:
set {_loc} to the location at arg-1, arg-2, arg-3 of the world arg-4
distance between the player and the location (0, 0, 0) is less than 200</pre>
====Location Of====
<pre>模型:
(location|position) of %location%
%location%'[s] (location|position)
加入的版本:
unknown
The location of a block or entity. This not only represents the x, y and z coordinates of the location but also includes the world and the direction an entity is looking (e.g. teleporting to a saved location will make the teleported entity face the same saved direction every time). 
Please note that the location of an entity is at its feet, use the head location to get the location of the head.
示例:
set {home.%player%} to the location of the player
message "Your home was set to %player's location% in %player's world%."</pre>
====Loop value====
<pre>模型:
[the] loop-<.+>
加入的版本:
1.0
The currently looped value.
示例:
# countdown:
loop 10 times:
	message "%11 - loop-number%"
	wait a second
# generate a 10x10 floor made of randomly coloured wool below the player:
loop blocks from the block below the player to the block 10 east of the block below the player:
	loop blocks from the loop-block to the block 10 north of the loop-block:
		set loop-block-2 to any wool</pre>
====Lore====
<pre>模型:
[the] line %number% of [the] lore of [%item stack/item type%]
[the] line %number% of %item stack/item type%'[s] lore
[the] %number%(st|nd|rd|th) line of [the] lore of [%item stack/item type%]
[the] %number%(st|nd|rd|th) line of %item stack/item type%'[s] lore
加入的版本:
2.1
An item's lore.
示例:
set the 1st line of the item's lore to "<orange>Excalibur 2.0"</pre>
====Max Health====
<pre>模型:
[the] max[imum] health of %living entities%
%living entities%'[s] max[imum] health
加入的版本:
2.0
The maximum health of an entity, e.g. 10 for a player
示例:
on join:
	set the maximum health of the player to 100
spawn a giant
set the last spawned entity's max health to 1000</pre>
====Maximum Stack Size====
<pre>模型:
[the] max[imum] stack[[ ]size] of %item stack%
%item stack%'[s] max[imum] stack[[ ]size]
加入的版本:
2.1
The maximum stack size of the specified material, e.g. 64 for torches, 16 for buckets, and 1 for swords.
示例:
send "You can only pick up %max stack size of player's tool% of %type of (player's tool)%" to player</pre>
====Me====
<pre>模型:
me
my[self]
加入的版本:
2.1.1
A 'me' expression that can be used in effect commands only.
示例:
!heal me
!kick myself
!give a diamond axe to me</pre>
====Message====
<pre>模型:
[the] [chat( |-)]message
[the] (join|log[ ]in)( |-)message
[the] (quit|leave|log[ ]out|kick)( |-)message
[the] death( |-)message
加入的版本:
1.4.6 (chat message), 1.4.9 (join & quit messages), 2.0 (death message)
The (chat) message of a chat event, the join message of a join event, the quit message of a quit event, or the death message on a death event. This expression is mostly useful for being changed.
示例:
on chat:
	player has permission "admin"
	set message to "<red>%message%"

on first join:
	set join message to "Welcome %player% to our awesome server!"
on join:
	player has played before
	set join message to "Welcome back, %player%!"

on quit:
	set quit message to "%player% left this awesome server!"

on death:
	set the death message to "%player% died!"</pre>
====Money====
<pre>模型:
cannot be used directly
加入的版本:
2.0
How much virtual money a player has (can be changed). 

Like all economy elements, this expression requires that Vault and a compatible economy plugin is installed.
示例:
message "You have %player's money%" # the currency name will be added automatically
remove 20$ from the player's balance # replace '$' by whatever currency you use
add 200 to the player's account # or omit the currency alltogether</pre>
====Name / Display Name====
<pre>模型:
[the] (player|tab)[ ]list name[s] of %players%
%players%'[s] (player|tab)[ ]list name[s]
[the] (display|nick|chat)[ ]name[s] of %slots/item stacks/living entities/players%
%slots/item stacks/living entities/players%'[s] (display|nick|chat)[ ]name[s]
[the] name[s] of %slots/item stacks/living entities/players%
%slots/item stacks/living entities/players%'[s] name[s]
加入的版本:
1.4.6 (players' name & display name), unknown (player list name), 2.0 (item name)
Represents a player's minecraft account name, chat display name, or playerlist name, or the custom name of an item or a living entity. 

The differences between the different names are: 
name: Minecraft account name of a player (unmodifiable), or the custom name of an item or mob (modifiable).
display name: The name of a player as displayed in the chat. This name can be changed freely and can include colour codes, and is shared among all plugins (e.g. chat plugins will use a changed name).
tab list name: The name of a player used in the player list that usually opens with the tab key. Please note that this is limited to 16 characters, including colour codes which are counted as 2 characters each, and that no two players can have the same tab list name at the same time.
Starting with Skript 2.1, the name and display name of entities have a different meaning: 'Name' sets the entity's name like a name tag does, while 'display name' will not only set the entity's name, but will also make it visible through blocks just like players' names.
示例:
on join:
	player has permission "name.red"
	set the player's display name to "<red>[admin]<gold>%name of player%"
	set the player's tablist name to "<green>%name of player%"
set the name of the player's tool to "Legendary Sword of Awesomeness"</pre>
====Named Item====
<pre>模型:
%item types% (named|with name[s]) %text%
加入的版本:
2.0
Directly names an item, useful for defining a named item in a script. If you want to (re)name existing items you can either use this expression or use set name of <item> to <text>.
示例:
give a diamond sword of sharpness 100 named "<gold>Excalibur" to the player
set tool of player to the player's tool named "<gold>Wand"
set the name of the player's tool to "<gold>Wand"</pre>
====Now====
<pre>模型:
now
加入的版本:
1.4
The current system time of the server. Use time to get the Minecraft time of a world.
示例:
broadcast "Current server time: %now%"</pre>
====Numbers====
<pre>模型:
[(integers) (between|from) %number% (and|to) %number%
%number% times
加入的版本:
1.4.6
All numbers between two given numbers, useful for looping.
Use 'numbers' if your start is not an integer and you want to keep the fractional part of the start number constant, or use 'integers' if you only want to loop integers.
An integer loop from 1 to a number x can also be written as 'loop x times'.
示例:
loop 5 times: # loops 1, 2, 3, 4, 5
loop numbers from 2.5 to 5.5: # loops 2.5, 3.5, 4.5, 5.5
loop integers from 2.9 to 5.1: # same as '3 to 5', i.e. loops 3, 4, 5</pre>
====Parse====
<pre>模型:
%text% parsed as (%*type%|"<.*>")
加入的版本:
2.0
Parses text as a given type, or as a given pattern. 
This expression can be used in two different ways: One which parses the entire text as a single instance of a type, e.g. as a number, and one that parses the text according to a pattern. 
If the given text could not be parsed, this expression will return nothing and the parse error will be set if some information is available. 
Some notes about parsing with a pattern: 
- The pattern must be a Skript pattern, e.g. percent signs are used to define where to parse which types, e.g. put a %number% or %items% in the pattern if you expect a number or some items there. 
- You have to save the expression's value in a list variable, e.g. set {parsed::*} to message parsed as "...". 
- The list variable will contain the parsed values from all %types% in the pattern in order. If a type was plural, e.g. %items%, the variable's value at the respective index will be a list variable, e.g. the values will be stored in {parsed::1::*}, not {parsed::1}.
示例:
set {var} to line 1 parsed as number
on chat:
	set {var::*} to message parsed as "buying %items% for %money%"
	if parse error is set:
		message "%parse error%"
	else if {var::*} is set:
		cancel event
		remove {var::2} from the player's balance
		give {var::1::*} to the player</pre>
====Parse Error====
<pre>模型:
[the] [last] [parse] error
加入的版本:
2.0
The error which caused the last parse operation to fail, which might not be set if a pattern was used and the pattern didn't match the provided text at all.
示例:
set {var} to line 1 parsed as integer
if {var} is not set:
	parse error is set:
		message "<red>Line 1 is invalid: %last parse error%"
	else:
		message "<red>Please put an integer on line 1!"</pre>
====Passenger====
<pre>模型:
[the] passenger[s] of %entities%
%entities%'[s] passenger[s]
加入的版本:
2.0
The passenger of a vehicle, or the rider of a mob. 

See also: vehicle (expression), vehicle (effect)
示例:
passenger of the minecart is a creeper or a cow
the saddled pig's passenger is a player</pre>
====Prefix/Suffix====
<pre>模型:
cannot be used directly
加入的版本:
2.0
The prefix or suffix as defined in the server's chat plugin.
示例:
on chat:
	cancel event
	broadcast "%player's prefix%%player's display name%%player's suffix%: %message%" to the player's world
set the player's prefix to "[<red>Admin<reset>] "</pre>
====Random====
模型:
[a] random %*type% [out] of %objects%
加入的版本:
1.4.9
Gets a random item out of a set, e.g. a random player out of all players online.
示例:
give a diamond to a random player out of all players
give a random item out of all items to the player
Random Number
模型:
[a] random (integer|number) (from|between) %number% (to|and) %number%
加入的版本:
1.4
A random number or integer between two given numbers. Use 'number' if you want any number with decimal parts, or use use 'integer' if you only want whole numbers.
Please note that the order of the numbers doesn't matter, i.e. random number between 2 and 1 will work as well as random number between 1 and 2.
示例:
set the player's health to a random number between 5 and 10
send "You rolled a %random integer from 1 to 6%!" to the player</pre>
====Region====
<pre>模型:
cannot be used directly
加入的版本:
2.1
The region involved in an event.
This expression requires a supported regions plugin to be installed.
示例:
on region enter:
	region is {forbidden region}
	cancel the event</pre>
====Region Members & Owners====
<pre>模型:
cannot be used directly
加入的版本:
2.1
A list of members or owners of a region.
This expression requires a supported regions plugin to be installed.
示例:
on entering of a region:
	message "You're entering %region% whose owners are %owners of region%".</pre>
====Regions At====
<pre>模型:
cannot be used directly
加入的版本:
2.1
All regions at a particular location.
This expression requires a supported regions plugin to be installed.
示例:
On click on a sign:
	line 1 of the clicked block is "[region info]"
	set {_regions::*} to regions at the clicked block
	if {_regions::*} is empty:
		message "No regions exist at this sign."
	else:
		message "Regions containing this sign: <gold>%{_regions::*}%<r>."</pre>
====Remaining Air====
<pre>模型:
[the] remaining air of %living entities%
%living entities%'[s] remaining air
加入的版本:
unknown
How much time a player has left underwater before starting to drown.
示例:
player's remaining air is less than 3 seconds:
	send "hurry, get to the surface!" to the player</pre>
====Rounding====
<pre>模型:
floor(%number%)
[(a|the)] round[ed] down %number%
round(%number%)
[(a|the)] round[ed] %number%
ceil[ing](%number%)
[(a|the)] round[ed] up %number%
加入的版本:
2.0
Rounds numbers normally, up (ceiling) or down (floor) respectively.
示例:
set {var} to rounded health of player
set line 1 of the block to round(1.5 * player's level)
set {_x} to floor({_y}) - ceil({_x})
add rounded down argument to the player's health</pre>
====Script Name====
<pre>模型:
[the] script[['s] name]
加入的版本:
2.0
Holds the current script's name (the file name without '.sk').
示例:
on script load:
	set {running.%script%} to true
on script unload:
	set {running.%script%} to false</pre>
====Shooter====
<pre>模型:
[the] shooter [of %projectile%]
加入的版本:
1.3.7
The shooter of a projectile. 
As of Skript 2.1, this can be changed to fake the shooter of the projectile.
示例:
shooter is a skeleton
add 1 to {game.points.%shooter of {game.ball}%}</pre>
====Sign Text====
<pre>模型:
[the] line %number% [of %block%]
[the] (1st|first|2nd|second|3rd|third|4th|fourth) line [of %block%]
加入的版本:
1.3
A line of text on a sign. Can be changed, but remember that there is a 16 character limit per line (including colour codes that use 2 characters each).
示例:
on rightclick on sign:
	line 2 of the clicked block is "[Heal]":
		heal the player
	set line 3 to "%player%"</pre>
====Skull====
<pre>模型:
[the] skull of %offline players/entities/entity types%
%offline players/entities/entity types%'[s] skull
加入的版本:
2.0
Gets a skull item representing a player or an entity.
示例:
give the victim's skull to the attacker
set the block at the entity to the entity's skull</pre>
====Spawn====
<pre>模型:
[the] spawn[s] [(point|location)[s]] [of %worlds%]
%worlds%'[s] spawn[s] [(point|location)[s]]
加入的版本:
1.4.2
The spawnpoint of a world.
示例:
teleport all players to spawn
set the spawn point of "world" to the player's location</pre>
====Speed====
<pre>模型:
[the] (walk[ing]|fl(y[ing]|ight))[( |-])speed of %players%
%players%'[s] (walk[ing]|fl(y[ing]|ight))[( |-])speed
加入的版本:
unknown
A player's walking or flying speed. Both can be changed, but values must be between -1 and 1 (excessive values will be changed to -1 or 1 respectively). Negative values reverse directions. 
Please note that changing a player's speed will change his FOV just like potions do. 
The default values are 0.2 for walk speed, and 0.1 for fly speed.
示例:
set the player's walk speed to 1
increase the argument's fly speed by 0.1
set the walk speed of the player to 0-(the player's walk speed) # reverses the player's speed</pre>
====Subtext====
<pre>模型:
[the] [(part|sub[ ](text|string)) of %texts% (between|from) (ind(ex|ices)|character[s])] %number% [(and|to) (index|character)] %number%
[the] (first|last) [%number%] character[s] of %texts%
[the] %number% (first|last) characters of %texts%
加入的版本:
2.1
Extracts part of a text. You can either get the first <x> characters, the last <x> characters, or the characters between indices <x> and <y>. The indices <x> and <y> should be between 1 and the length of the text (other values will be fit into this range).
示例:
set {_s} to the first 5 characters of the text argument
message "%subtext of {_s} from characters 2 to (the length of {_s} - 1)%" # removes the first and last character from {_s} and sends it to the player or console</pre>
====Target====
<pre>模型:
[the] target[[ed] %*entity type%] [of %living entities%]
%living entities%'[s] target[[ed] %*entity type%]
加入的版本:
unknown
For players this is the entity at the crosshair, while for mobs and experience orbs it represents the entity they are attacking/following (if any).
示例:
on entity target:
    entity's target is a player
    send "You're being followed by an %entity%!" to target of entity</pre>
====Targeted Block====
<pre>模型:
[the] target[ed] block[s] [of %players%]
%players%'[s] target[ed] block[s]
[the] actual[ly] target[ed] block[s] [of %players%]
%players%'[s] actual[ly] target[ed] block[s]
加入的版本:
1.0
The block at the crosshair. This regards all blocks that are not air as fully opaque, e.g. torches will be like a solid stone block for this expression.
示例:
# A command to set the block a player looks at to a specific type:
command /setblock <material>:
    trigger:
        set targeted block to argument</pre>
====Time====
<pre>模型:
[the] time [(in|of) %worlds%]
%worlds%'[s] time
加入的版本:
1.0
The time of a world.
示例:
time in world is between 18:00 and 6:00:
	broadcast "It's night-time, watch out for monsters!"</pre>
====Tool====
<pre>模型:
[the] (tool|held item|weapon) [of %living entities%]
%living entities%'[s] (tool|held item|weapon)
加入的版本:
1.0
The item a player is holding. 
As of Skript 2.1 this expression can also be used for mobs, e.g. to change the weapon of a zombie.
示例:
player is holding a pickaxe
# is the same as
player's tool is a pickaxe</pre>
====Type of====
<pre>模型:
[the] type of %entity types/item stacks%
%entity types/item stacks%'[s] type
加入的版本:
1.4
The type of a block, item, or entity. The type of an item is only its id and data value, i.e. it ignores the amount, enchantments etc., and the type of an entity is e.g. 'wolf' or 'player'.
示例:
on rightclick on an entity:
	message "This is a %type of clicked entity%!"</pre>
====UUID====
<pre>模型:
[the] UUID of %players/worlds%
%players/worlds%'[s] UUID
加入的版本:
2.1.2
The UUID of a player or world.
In the future there will be an option to use a player's UUID instead of the name in variable names (i.e. when %player% is used), but for now this can be used.
Please note that this expression does not work for offline players!
示例:
# prevents people from joining the server if they use the name of a player
# who has played on this server at least once 加入的版本 this script has been added
on login:
	{uuids.%name of player%} exists:
		{uuids.%name of player%} is not UUID of player
		kick player due to "Someone with your name has played on this server before"
	else:
		set {uuids.%name of player%} to UUID of player</pre>
====Vehicle====
<pre>模型:
[the] vehicle[s] of %entities%
%entities%'[s] vehicle[s]
加入的版本:
2.0
The vehicle an entity is in, if any. This can actually be any entity, e.g. spider jockeys are skeletons that ride on a spider, so the spider is the 'vehicle' of the skeleton.
See also: passenger
示例:
vehicle of the player is a minecart</pre>
====Version====
<pre>模型:
([craft]bukkit|minecraft|skript)( |-)version
加入的版本:
2.0
The version of Bukkit, Minecraft or Skript respectively.
示例:
message "This server is running Minecraft %minecraft version% on Bukkit %bukkit version%"
message "This server is powered by Skript %skript version%"</pre>
====Weather====
<pre>模型:
[the] weather [(in|of) %worlds%]
%worlds%'[s] weather
加入的版本:
1.0
The weather in the given or the current world.
示例:
set weather to clear
weather in "world" is rainy</pre>
====World====
<pre>模型:
[the] world [of %entity/location%]
%entity/location%'[s] world
加入的版本:
1.0
The world the event occurred in.
示例:
world is "world_nether"
teleport the player to the world's spawn
set the weather in the player's world to rain</pre>
====Worlds====
<pre>模型:
[(the|all)] worlds
加入的版本:
1.0
All worlds of the server, useful for looping.
示例:
loop all worlds:
	broadcast "You're in %loop-world%" to loop-world</pre>
====X of Item====
<pre>模型:
%number% of %item stacks/entity type%
加入的版本:
1.2
An expression to be able to use a certain amount of items where the amount can be any expression. Please note that is expression is not stable and might be replaced in the future.
示例:
give level of player of pickaxes to the player</pre>
====Yaw / Pitch====
<pre>模型:
[the] (yaw|pitch) of %locations%
%locations%'[s] (yaw|pitch)
加入的版本:
2.0
The yaw or pitch of a location, in degrees.
示例:
log "%player%: %location of player%, %player's yaw%, %player's pitch%" to "playerlocs.log"</pre>

===循环===
Loop循环会在满足条件的情况下反复执行效果，经典的Loop循环格式是这样的:
<pre>
loop <expression to loop>:
	<condition(s)>
	<effect(s)>
</pre>
一个循环将会不断地检测表达式的所有元素，如 所有玩家 世界 物品等。

Loop中的条件和效果会被这些元素使用。

条件可以是 ‘loop-<元素>’, 如 send "hello" to loop-player.

当一个循环中的一个条件不满足循环将开始循环的下一个元素。你可以使用stop来直接停止循环。

简单的循环可以在包括表达式后被一个条件或效果替换。如给所有人火把可以替换循环检测所有玩家然后给予火把。

====可以循环的值====
不止一个变量的表达式都可以参加循环。如  ‘all players’, ‘worlds’, 等。兼容所有的变量，也可以被循环使用。

你也可以使用表达式列表，如循环受害者和攻击者，然后使他们执行一些代码。

====变量列表====
当循环变量列表时，也可以使用 loop-index ，这是循环 loop-value 的另一种方式。

loop-value 是当前循环变量的值, loop-index 是变量最后部分的名字 (可以使用通配符*)。下面的示例将在列表变量中增加所有的值:
<pre>
loop {var::*}:
	set {var::%loop-index%} to loop-value + 1
</pre>
====While循环====
从2.0版本开始你就可以使用While循环，只要满足条件，将只保持重复的循环。While的循环格式是这样的:
<pre>
while <condition>:
	<code>
</pre>
请注意这种类型的循环，如果条件满足将会一直执行。

===命令===
创建Skript自定义命令并不难，但是Skript不适合创建其他已有插件命令，请创造全新的指令。

自定义指令基础语法如下
<pre>
command /commandname <arguments>: # arguments are explained below
	description: A description of what this command does
	usage: How to use the command, e.g. /commandname <arguments>  # If omitted this defaults to something similar to how the command was defined above.
	permission: required.permission.to.use.this.command  # If omitted this command can be used by everyone regardless of permissions.
	permission message: Message to send if the player doesn't have the required permission to use this command  # If omitted this defaults to "You don't have the required permission to use this 
command"
	executable by: players/console/players and console  # If omitted this command can be executed by players and the console.
	aliases: /c, /comname. # a list of aliases of the command which are usually abbreviations of the command
	trigger:
		put conditions and effects here that will be checked/executed when the command is used.
解：
command /XXXXXX 参数[可选]:
    描述:
    如何使用:
    权限:
    没有权限是显示的信息:
    可以被XX执行:
    别名:
    触发器:
</pre>
命令的参数是这样的<argtype> 或这样的 <argtype = 默认值>,   <item> or <item=water bucket>。

默认值也可以是一个表达式'' in which case it has to be put into percent signs: <item=%tool%>.''

参数也可以用文字表示，如：
<pre>
command /give <items> to <player>:
</pre>
这个指令的格式为  /give a diamond to Njol.
你可以将可选参数用[ ]扩起，如在某半径内寻找某种怪物类型—— <pre>command /find <entity type> [in radius <integer=100>]</pre>.

这样的命令可以这样用 /find creepers or /find zombies in radius 20, where the radius will default to 100 if omitted.

这是一个简单的自定义指令的例子:
#获取手中物品的ID
<pre>
command /id <item=%tool%>:
	description: Find the ID of the item you're holding, or any given one.
	usage: /id [type]
	executable by: players
	trigger:
		message "The ID of %arg 1% is %id of arg 1%"
</pre>
自定义命令可以写在脚本的任何地方——命令不需要事件。

如果一个命令与一些触发器有关，我建议把命令和触发器放到同一文件，否则就可以把它放到任何文件中。

你可以写一个包含所有指令的大脚本，或给每个指令单独的脚本。

下面是生成一个可以用金粒换治疗的自定义命令:
<pre>
command /healer:
	permission: healer.create
	description: spawns a healer villager which can heal players
	trigger:
		spawn a priest
		set {healers::%spawned villager%} to true
		set the name of the spawned villager to "Healer"
 
on rightclick on a priest:
	player has permission "healer.use"
	player is holding a gold ingot
	{healers::%clicked villager%} is true
	player's health is below 10
	heal the player by 5 hearts
	remove 1 gold ingot from the player

</pre>

===类型===
This is a list of most types that Skript uses (types that are not listed are not needed by the user). A type is a kind of object, e.g. player, number, or text.
Many types can be used as command arguments (‘<type>’, e.g. <number>) and almost all types can be used as loop-values (‘loop-type’, e.g. loop-block). The patterns listed for each type below reference to this.
The usage listed above the patterns for each type describe how you can define an instance of the type in a script, e.g. how to include text properly or how to write a number. The usage does usually not include any expressions that represent an instance of the type, e.g. blocks cannot be defined in a script, but you can use one of the many block expressions to get a block.

====Biome====
<pre>类型参数:
swampland, forest, taiga, desert, plains, hell, sky, ocean, river, extreme hills, frozen ocean, frozen river, ice plains, ice mountains, mushroom island, mushroom shore, beach, desert hills, forest hills, taiga hills, small mountains, jungle, jungle hills
类型名字:
biome[s]
加入的版本:
1.4.4
All possible biomes Minecraft uses to generate a world.
示例:
biome at the player is desert</pre>
====Block====
<pre>类型参数:
不能在脚本中使用
类型名字:
block[s]
加入的版本:
1.0
A block in a world. It has a location and a type, and can also have a direction (mostly a facing), an inventory, or other special properties.</pre>
====Boolean====
<pre>类型参数:
true/yes/on or false/no/off
类型名字:
boolean[s]
加入的版本:
1.0
A boolean is a value that is either true or false. Other accepted names are 'on' and 'yes' for true, and 'off' and 'no' for false.
示例:
set {config.%player%.use mod} to false</pre>
====Chunk====
<pre>类型参数:
不能在脚本中使用
类型名字:
chunk[s]
加入的版本:
2.0
A chunk is a cuboid of 16×16×<world height> (x×z×y) blocks (the world height is usually 128 or 256). Chunks are spread on a fixed rectangular grid in their world, where the chunk (0,0) contains the blocks (0,0,0) to (15,15,<world height> - 1).</pre>
====Colour====
<pre>类型参数:
black, dark grey/dark gray, grey/light grey/gray/light gray/silver, white, blue/dark blue, cyan/aqua/dark cyan/dark aqua, light blue/light cyan/light aqua, green/dark green, light green/lime/lime green, yellow/light yellow, orange/gold/dark yellow, red/dark red, pink/light red, purple/dark purple, magenta/light purple, brown/indigo
类型名字:
colo[u]r[s]
加入的版本:
unknown
Wool, dye and chat colours. 
Please note that the same colours are used for chat and wool so that you can use any colour expression to colour chat, e.g. message "<%colour of sheep%>this colour". Minecraft however uses slightly different colours for chat and sheep, with the main difference being that there exists no brown chat colour, but there exists another blue one instead, thus 'brown' and 'indigo' are the same colour.
示例:
color of the sheep is red or black
set the colour of the block to green
message "You're holding a <%color of tool%>%color of tool%<reset> wool block"</pre>
====Command Sender====
<pre>类型参数:
use the console for the console
see player for players.
类型名字:
[command[s]][ ](sender|executor)[s]
加入的版本:
1.0
A player or the console.
示例:
on command /pm:
	command sender is not the console
	chance of 10%
	give coal to the player
	message "You got a piece of coal for sending that PM!"</pre>
====Damage Cause====
<pre>类型参数:
contact, attack, projectile, suffocation, fall, fire, burning, melting, lava, drowning, block explosion, entity explosion, void, lightning, suicide, starvation, poison, potion, wither, falling block, thorns, unknown
类型名字:
damage cause[s]
加入的版本:
2.0
The cause/type of a damage event, e.g. lava, fall, fire, drowning, explosion, poison, etc.
Please note that support for this type is very rudimentary, e.g. lava, fire and burning, as well as projectile and attack are considered different types.</pre>
====Date====
<pre>类型参数:
不能在脚本中使用
类型名字:
date[s]
加入的版本:
1.4
A date is a certain point in the real world's time which can currently only be obtained with now.
See time and timespan for the other time types of Skript.
示例:
set {_yesterday} to now
subtract a day from {_yesterday}
# now {_yesterday} represents the date 24 hours before now</pre>
====Direction====
类型参数:
<pre>see direction (expression)
类型名字:
direction[s]
加入的版本:
2.0
A direction, e.g. north, east, behind, 5 south east, 1.3 meters to the right, etc.
Locations and some blocks also have a direction, but without a length.
Please note that directions have changed extensively in the betas and might not work perfectly. They can also not be used as command arguments.
示例:
set the block below the victim to a chest
loop blocks from the block infront of the player to the block 10 below the player:
	set the block behind the loop-block to water</pre>
====Enchantment====
<pre>类型参数:
protection, respiration, punch, projectile protection, smite, fortune, infinity, feather falling, flame, knockback, sharpness, aqua affinity, looting, fire aspect, silk touch, blast protection, power, thorns, efficiency, fire protection, bane of arthropods, unbreaking, luck of the sea, lure
类型名字:
enchantment[s]
加入的版本:
1.4.6
An enchantment, e.g. 'sharpness' or 'fortune'. Unlike enchantment type this type has no level, but you usually don't need to use this type anyway.</pre>
====Enchantment Type====
<pre>类型参数:
<enchantment> [<level>]
类型名字:
enchant(ing|ment) type[s]
加入的版本:
1.4.6
An enchantment with an optional level, e.g. 'sharpness 2' or 'fortune'.
示例:
enchant the player's tool with sharpness 5
helmet is enchanted with waterbreathing</pre>
====Entity====
<pre>类型参数:
player, op, wolf, tamed ocelot, powered creeper, zombie, unsaddled pig, fireball, arrow, dropped item, item frame, etc.
类型名字:
entit(y|ies)
加入的版本:
1.0
An entity is something in a world that's not a block, e.g. a player, a skeleton, or a zombie, but also projectiles like arrows, fireballs or thrown potions, or special entities like dropped items, falling blocks or paintings.
示例:
entity is a zombie or creeper
player is an op
projectile is an arrow
shoot a fireball from the player</pre>
====Entity Type====
<pre>类型参数:
Detailed usage will be added eventually
类型名字:
entity[ ]type[s]
加入的版本:
1.3
The type of an entity, e.g. player, wolf, powered creeper, etc.
示例:
victim is a cow
spawn a creeper
targeted entity is an enderman holding a rose
spawn 10 red, green or blue sheep
spawn a falling anvil 4 meters above the player
kill all skeleton horses in all worlds</pre>
====Entity Type with Amount====
<pre>类型参数:
<number> <entity type>
类型名字:
cannot be used directly
加入的版本:
1.3
An entity type with an amount, e.g. '2 zombies'. I might remove this type in the future and make a more general 'type' type, i.e. a type that has a number and a type.
示例:
spawn 5 creepers behind the player</pre>
====Experience====
<pre>类型参数:
[<number>] ([e]xp|experience)
类型名字:
cannot be used directly
加入的版本:
2.0
Experience points. Please note that Bukkit only allows to give XP, but not remove XP from players. You can however change a player's level and level progress freely.
示例:
give 10 xp to the player</pre>
====Game Mode====
<pre>类型参数:
creative/survival/adventure
类型名字:
game[ ]mode[s]
加入的版本:
1.0
The game modes survival, creative and adventure.
示例:
player's gamemode is survival
set the player argument's game mode to creative</pre>
====Inventory====
<pre>类型参数:
不能在脚本中使用
类型名字:
inventor(y|ies)
加入的版本:
1.0
An inventory of a player or block. Inventories have many effects and conditions regarding the items contained.
An inventory has a fixed amount of slots which represent a specific place in the inventory, e.g. the helmet slot for players (Please note that slot support is still very limited but will be improved eventually).</pre>
====Inventory Slot====
<pre>类型参数:
不能在脚本中使用
类型名字:
[inventory ]slot[s]
加入的版本:
unknown
Represents a single slot of an inventory. Notable slots are the armour slots and furnace slots. 
The most important property that distinguishes a slot from an item is its ability to be changed, e.g. it can be set, deleted, enchanted, etc. (Some item expressions can be changed as well, e.g. items stored in variables. Speaking of which: slots are never saved to variables, only the items they represent at the time when the variable is set). 
Please note that the tool is a slot, but it can actually change its position, i.e. doesn't always represent the same slot.
示例:
set tool of player to dirt
delete helmet of the victim
set the colour of the player's tool to green
enchant the player's chestplate with projectile protection 5</pre>
====Item / Material====
<pre>类型参数:
[<number> [of]] <alias> [of <enchantment> <level>], Where <alias> must be an alias that represents exactly one item (i.e cannot be a general alias like 'sword' or 'plant')
类型名字:
item
material
加入的版本:
1.0
An item, e.g. a stack of torches, a furnace, or a wooden sword of sharpness 2. Unlike item type an item can only represent exactly one item (e.g. an upside-down cobblestone stair facing west), while an item type can represent a whole range of items (e.g. any cobble stone stairs regardless of direction).
You don't usually need this type except when you want to make a command that only accepts an exact item.
Please note that currently 'material' is exactly the same as 'item', i.e. can have an amount & enchantments.
示例:
set {_item} to type of the targeted block
{_item} is a torch</pre>
====Item Type====
<pre>类型参数:
[<number> [of]] [all/every] <alias> [of <enchantment> [<level>] [,/and <more enchantments...>]]
类型名字:
item[ ]type[s]
items
materials
加入的版本:
1.0
An item type is an alias, e.g. 'a pickaxe', 'all plants', etc., and can result in different items when added to an inventory, and unlike items they are well suited for checking whether an inventory contains a certain item or whether a certain item is of a certain type.
An item type can also have one or more enchantments with or without a specific level defined, and can optionally start with 'all' or 'every' to make this item type represent all types that the alias represents, including data ranges.
示例:
give 4 torches to the player
add all slabs to the inventory of the block
player's tool is a diamond sword of sharpness
remove a pickaxes of fortune 4 from {stored items::*}
set {_item} to 10 of every upside-down stair
block is dirt or farmland</pre>
====Living Entity====
<pre>类型参数:
see entity, but ignore inanimate objects
类型名字:
living[ ]entit(y|ies)
加入的版本:
1.0
A living entity, e.g. a mob or player, not inanimate entities like projectiles or dropped items.
示例:
spawn 5 powered creepers
shoot a zombie from the creeper</pre>
====Location====
<pre>类型参数:
See location at (expression)
类型名字:
location[s]
加入的版本:
1.0
A location in a world. Locations are world-specific and even store a direction, e.g. if you save a location and later teleport to it you will face the exact same direction you did when you saved the location. 

In the case of the teleport effect you can set a location's yaw and pitch to 0 to prevent this behaviour.</pre>
====Money====
<pre>类型参数:
<number> $ or $ <number>, where '$' is your server's currency, e.g. '10 rupees' or '£5.00'
类型名字:
cannot be used directly
加入的版本:
2.0
A certain amount of money. Please note that this differs from numbers as it includes a currency symbol or name, but usually the two are interchangeable, e.g. you can both add 100$ to the player's balance and add 100 to the player's balance. 

Like all economy elements, this type requires that Vault and a compatible economy plugin is installed.
示例:
add 10£ to the player's account
remove Fr. 9.95 from the player's money
set the victim's money to 0
increase the attacker's balance by the level of the victim * 100</pre>
====Number====
<pre>类型参数:
[-]###[.###] (any amount of digits; very large numbers will be truncated though)
类型名字:
num[ber][s]
加入的版本:
1.0
A number, e.g. 2.5, 3, or -9812454.
Please note that many expressions only need integers, i.e. will discard any frational parts of any numbers without producing an error.
示例:
set the player's health to 5.5
set {_temp} to 2*{_temp} - 2.5</pre>
====Object====
<pre>类型参数:
不能在脚本中使用
类型名字:
cannot be used directly
加入的版本:
1.0
The supertype of all types, meaning that if %object% is used in e.g. a condition it will accept all kinds of expressions.
Offlineplayer
类型参数:
不能在脚本中使用
类型名字:
offline[ ]player[s]
加入的版本:
unknown
A player that is possibly offline. See player for more information. Please note that while all effects and conditions that require a player can be used with an offline player as well, they will not work if the player is not actually online.</pre>
====Player====
<pre>类型参数:
不能在脚本中使用
类型名字:
player[s]
加入的版本:
1.0
A player. Depending on whether a player is online or offline several actions can be performed with them, though you won't get any errors when using effects that only work if the player is online (e.g. changing his inventory) on an offline player.
You have two possibilities to use players as command arguments: <player> and <offline player>. The first requires that the player is online and also accepts only part of the name, while the latter doesn't require that the player is online, but the player's name has to be entered exactly.</pre>
====Potion Effect Type====
<pre>类型参数:
speed, slowness, haste, mining fatigue, strength, instant health, instant damage, jump boost, nausea, regeneration, resistance, fire resistance, water breathing, invisibility, blindness, night vision, hunger, weakness, poison, wither
类型名字:
potion[[ ]effect][[ ]type][s]
加入的版本:
unknown
A potion effect, e.g. 'strength' or 'swiftness'.
示例:
apply swiftness 5 to the player
apply potion of speed 2 to the player for 60 seconds
remove invisibility from the victim</pre>
====Projectile====
<pre>类型参数:
arrow, fireball, snowball, thrown potion, etc.
类型名字:
projectile[s]
加入的版本:
1.0
A projectile, e.g. an arrow, snowball or thrown potion.
示例:
projectile is a snowball
shoot an arrow at speed 5 from the player</pre>
====Region====
<pre>类型参数:
"region name"
类型名字:
cannot be used directly
加入的版本:
2.1
A region of a regions plugin. Skript currently supports WorldGuard, Factions, GriefPrevention and PreciousStones.
Please note that some regions plugins do not have named regions, some use numerical ids to identify regions, and some may have regions with the same name in different worlds, thus using regions like "region name" in scripts may or may not work.</pre>
====Text====
<pre>类型参数:
simple: "..."
quotes: "...""..."
expressions: "...%expression%..."
percent signs: "...%%..."
类型名字:
(text|string)[s]
加入的版本:
1.0
Text is simply text, i.e. a sequence of characters, which can optionally contain expressions which will be replaced with a meaningful representation (e.g. %player% will be replaced with the player's name).
Because scripts are also text, you have to put text into double quotes to tell Skript which part of the line is an effect/expression and which part is the text.
Please read the article on Texts and Variable Names to learn more.
示例:
broadcast "Hello World!"
message "Hello %player%"
message "The id of ""%type of tool%"" is %id of tool%."</pre>
====Time====
<pre>类型参数:
##:##
##[:##][ ]am/pm
类型名字:
time[s]
加入的版本:
1.0
A time is a point in a minecraft day's time (i.e. ranges from 0:00 to 23:59), which can vary per world.
See date and timespan for the other time types of Skript.
示例:
at 20:00:
	time is 8 pm
	broadcast "It's %time%"
Timeperiod
类型参数:
##:## - ##:##
dusk/day/dawn/night
类型名字:
time[ ]period[s]
duration[s]
加入的版本:
1.0
A period of time between two times. Mostly useful 加入的版本 you can use this to test for whether it's day, night, dusk or dawn in a specific world.
This type might be removed in the future as you can use 'time of world is between x and y' as a replacement.
示例:
time in world is night</pre>
====Timespan====
<pre>类型参数:
<number> [minecraft/mc/real/rl/irl] ticks/seconds/minutes/hours/days [[,/and] <more...>]
[###:]##:##[.####] ([hours:]minutes:seconds[.milliseconds])
类型名字:
time[ ]span[s]
加入的版本:
1.0
A timespan is a difference of two different dates or times, e.g '10 minutes'. Timespans are always displayed as real life time, but can be defined as minecraft time, e.g. '5 minecraft days and 12 hours'.
See date and time for the other time types of Skript.
示例:
every 5 minecraft days:
	wait a minecraft second and 5 ticks
every 10 mc days and 12 hours:
	halt for 12.7 irl minutes, 12 hours and 120.5 seconds</pre>
====Tree Type====
<pre>类型参数:
[any] <general tree/mushroom type>, e.g. tree/any jungle tree/etc.
<specific tree/mushroom species>, e.g. red mushroom/small jungle tree/big regular tree/etc.
类型名字:
tree[ ]type[s]
tree[s]
加入的版本:
unknown
A tree type represents a tree species or a huge mushroom species. These can be generated in a world with the generate tree effect.
示例:
grow any regular tree at the block
grow a huge red mushroom above the block</pre>
====Type====
<pre>类型参数:
See the type name patterns of all types - including this one
类型名字:
type[s]
加入的版本:
2.0
Represents a type, e.g. number, object, item type, location, block, world, entity type, etc.
This is mostly used for expressions like 'event-<type>', '<type>-argument', 'loop-<type>', etc., e.g. event-world, number-argument and loop-player.
示例:
{variable} is a number # check whether the variable contains a number, e.g. -1 or 5.5
{variable} is a type # check whether the variable contains a type, e.g. number or player
{variable} is an object # will always succeed if the variable is set as everything is an object, even types.
disable PvP in the event-world
kill the loop-entity</pre>
====Visual Effect====
<pre>类型参数:
ender signal, mobspawner flames, potion break, smoke, hurt, sheep eating, wolf hearts, wolf shaking, wolf smoke
类型名字:
(visual|particle) effect[s]
加入的版本:
2.1
A visible effect, e.g. particles.
示例:
show wolf hearts on the clicked wolf
play mob spawner flames at the targeted block to the player</pre>
====Weather Type====
<pre>类型参数:
clear/sun/sunny, rain/rainy/raining, and thunder/thundering/thunderstorm
类型名字:
weather[ ]type[s]
weather condition[s]
weather[s]
加入的版本:
1.0
The weather types sunny, rainy, and thundering.
示例:
is raining
is sunny in the player's world
message "It is %weather in the argument's world% in %world of the argument%"</pre>
====World====
<pre>类型参数:
"world_name", e.g. "world"
类型名字:
world[s]
加入的版本:
1.0
One of the server's worlds. Worlds can be put into scripts by surrounding their name with double quotes, e.g. "world_nether", but this might not work reliably as text uses the same syntax.
示例:
broadcast "Hello!" to "world_nether"</pre>

===文本===
====基础文本====
在脚本中使用文本非常的简单。

如，想要给玩家发送‘Hello!’你可以使用
<pre> send "Hello!" to pl ayer</pre>
你必须在文本旁用双引号<pre>" "</pre>括起来使用文本。如果要在文本中使用双引号的话，变成这样
<pre>"" "" 
"What's this ""thing"" you're talking about?"
</pre>
如果你想在文本中使用玩家名称的话，使用%player%来代替。

如 send "Hello %player%!" to player 会给作者发送 ‘Hello Njol!’ 。

类似的表达式都可以工作，如 message "The block above the block you're looking at is a %block above targeted block%". 

如果你想要使用百分号的话，双写——<pre> "100%%!"</pre>
====颜色与格式====
颜色和格式在消息中可以有两个方式存在。

一是普通的 ‘&x’/‘§x’ 颜色代码

二是使用Skript的 <colour> 代码，如 <pre>broadcast "<red><bold>Important Information:<reset> <blue><u>This server needs more mods!"</pre>

你也可以在文本中使用玩家物品的颜色，如<pre> "<%colour of tool%>this text is coloured depending on the player's held item!"</pre>

简单的颜色和格式如——
<pre>可用的颜色和格式
: black, dark grey/dark gray, grey/light grey/gray/light gray/silver, white, blue/dark blue, cyan/aqua/dark cyan/dark aqua, light blue/light cyan/light aqua, green/dark green, light green/lime/lime green, yellow/light yellow, orange/gold/dark yellow, red/dark red, pink/light red, purple/dark purple, magenta/light purple, brown/indigo
chat styles: bold/b, italics/italic/i, strikethrough/strike/s, underlined/underline/u, magic, reset/r</pre>
其他语言也许可以使用其他颜色，但可用的极少。如，使用颜色方面的表达式[对颜色指令很有用]，脚本经常使用英文的颜色代码。
====高级语法====
Skript 2.0版本及以上可以比只把他们放到文本中更高级的使用名词——

"a %expression" 或 "an %expression"将把适合的文字放入表达式，如 “a fish”, “an apple”, 或 “a pickaxe and an emerald”. 

这类似的，将允许使用 the("the %expression%"), 即使这在英语中几乎不明显， 只有一些名词，如“空气”将在这种情况下的文章下完全删除。

请注意其他语言你需要使用那个语言的文章，如德语 "der %expression" or "ein %expression%" <Ref>我是来翻译英语的不是翻译德语的(╯‵□′)╯︵┻━┻</ref>

"%expression%s" 兼容 "<数字> %expression%" (数字比1大) 将会使后面的表达式使用复数 。

如 "2 %block%" 会表现出 “2 logs” (数字也可以在另一个表达式使用，如 "%number-argument% %item-argument%" 会出现 “5 pickaxes” 或 “1 pickaxe”). 

这个语法会在任何语言使用。

====变量名====
变量名与文本十分相似，不过你需要用{ }括起。<pre> {变量}</pre>

表达式不适用高级语法。

===变量===
变量是Skript储存数据的方式，所有的变量都有一个名字，一个值。

你可以把变量放在任何地方去替换一些东西，如用变量的位置来替换一个位置。

这可以用简单的家指令：做一个变量'home'，然后再输入指令时传送到这个位置。

如要使用变量，把它的名字放到{ }内，像这样: {变量名}. 变量的名字经常包含表达式，如要为所有玩家每人一个家，变量名应使用 {home.%player%} 。

当变量载入时 %player% 将会被替换成玩家名字。

所有的变量都在‘variables.csv’ 中储存，它可在插件的目录里找到。请不要自行修改文件。如果你做错了一些东西一些变量会永久失效。
变量只是会时常写入这里,所以服务器崩溃也许会是你丢失一些变量。

从 2.0 版本开始将可以允许你使用数据库，这样你就可以共享变量。

有3种类型的变量: 普通变量，本地变量和选项变量。

普通变量是独一无二的，在插件中只能有一个普通变量叫这个名字，它们在服务器重启时会被保存。

本地变量的格式是{_名字}这样的，允许不同脚本有相同名字的本地比那里，如下面的触发器:
<pre>
on join:
  set {_player} to player
  wait a minute
  message "%{_player}%" # the local variable is unchanged no matter how many players joined in the meantime
</pre>
如果是普通变量的话会把全局的player都展示出来

本地变量在没有它们的用处的时候会被自动删除，并不会使用存储器，但当服务器重启或脚本重载时本地变量会丢失。

选项变量的格式是这样的:
<pre>
options:
  option name = option value
</pre>
在调用选项变量的时候你可以使用 {@option name}. 这将会在触发器运行之前把变量内容完全替换为你设置的变量值。

所以你可以把任何东西放到选项变量中，甚至是脚本。 不要在选项变量中使用百分号，会保留。
====变量的列出====
列出变量的变量是这样的<pre> {variable name::*} </pre>并且可以添加元素并使用默认的添加和移除效果移除元素,当被删除时会删除所有在列表上的值。

您可以使用{variable name::index}访问变量列表的特定值：其中index是那个特定值。特定值可以是任何东西，如一个玩家的名字，数字，但当为列表增加变量时，新的特定值会变成一个数字。

变量列表可以这样被循环<pre> {list variable::*}</pre>

其中循环值可以使用 loop-value 特定值可以使用 loop-index.

列出变量对于在消息中展示一些列表很有用，如一些在线的管理员，首先把他们列到同一变量，然后使用列出变量。(见下方的例子).

最好是使用本地变量列表{_local list variable::*}
====好吃的栗子====
这里是一些栗子

检查一共有多少人登入进你的服务器过:
<pre>
# if you add a 'variables:' section to your script, the variables defined there will be set to the given value if they don't exist
# when the script is loaded. You cannot change an existing variable's value this way however, in particular if you
# change the variables' values here the actual variables will not be changed at all.
variables:
	{logincount} = 0
 
on login:
	add 1 to {logincount}
 
command /logincount:
	description: Find out how many people have ever logged into this server
	trigger:
		message "Since its beginnings <green>%{logincount}%<reset> people have logged into this server"
</pre>

简单的home脚本:
<pre>
command /sethome:
	permission: skript.home
	description: Set your home
	trigger:
		set {home.%player%} to location of player
		message "Set your home to <grey>%location of player%<reset>"
 
command /home:
	permission: skript.home
	description: Teleport yourself to your home
	trigger:
		if {home.%player%} is not set:
			message "You have not set your home yet!"
			stop trigger
		teleport player to {home.%player%}
</pre>
显示在线管理员的脚本
<pre>:
command /staff:
	description: Shows online staff
	trigger:
		loop all players:
			loop-player has permission "is.staff"
			add loop-player to {_online staff::*}
 
		size of {_online staff::*} is 0:
			message "No staff currently online! Happy griefing ;)!"
		else:
			message "Online staff: %{_online staff::*}%"

</pre>
[[Category:编程]]