2. 编织 weave

到目前为止，我们一直以最基础的方式构建故事的分支，从“选项”到“页面”。

但这要求我们命名故事中的每个目的地且保持唯一性，可能会减慢编写速度并阻挠较小的分支。

INK 拥有更为强大的语法，旨在简化始终向前的故事流（写起来像大多数的故事，而非计算机程序）。

这种系统称为“编织”（weave），它由基础语法和选项语法，以及两个新功能构成：“收束标记 - ”，“选项与收束的嵌套”。

2.1 收束 gathers

收束（gathers） - 将小分支收回到一起。让我们看这个例子：

“怎么了？”我的主人问。
	*	“我有些累。”[]我重复道。
		“确实，” 他答道。 “这太糟了。”
	*	“没事，先生！”[] 我回应道。
	*  我说，这次旅行真可怕。”[] 我不想再继续了。”
		“啊，” 他有些动容。 "你看起来很沮丧。明天，情况会好些的。"

在真正的游戏中，这三个选项都可能导致相同的结果，Fogg 先生离开了房间。我们可用收束来执行此操作，而无需创建任何新结点或新跳转。

“怎么了？”我的主人问。
	*	“我有些累。”[]我重复道。
		“确实，” 他答道。 “这太糟了。”
	*	“没事，先生！”[] 我回应道。
	*  我说，这次旅行真可怕。”[] 我不想再继续了。”
		“啊，” 他有些动容。 "你看起来很沮丧。明天，情况会好些的。"
    
    -	Fogg 先生离开了房间。

我们可将这些“收束和分支”串在一起，让故事始终向前运行。

=== escape === 
我跑出森林，狗跟在我后面。

	* 我检查了下珠宝[]，都还在我的钱包里，这感觉就像步入了春天。 <>
	
	* 我没停下来喘口气[]，继续向前跑。<>

	*	我欢呼了出来。 <>

- 	路没多远了！Mackie 会发动引擎，然后我就安全了。//收束
  
	*	我来到路边四处张望[]。 你能相信吗？
	* 我不该总是说，Mackie一直很可靠[]。他从未让我失望过。更确切地说，从来没有，直到那晚前。

-	路旁边是空的。 Mackie 不见了。//再次收束

这是最基本的编织。本节后面还详细介绍了编织的嵌套、包含选项和跳转、内部跳转、以及根据前面的经历来影响后续的内容。

编织的哲学

编织不仅仅是方便分支收束，也是一种强大的内容创作的方式。上面的示例就已有4种路线，甚至可能会更复杂。使用普通的跳转，必须点到点的检查分支，且很容易出错。

通过编织，只需从顶部开始，就能运行到故事底部。在基本编织结构中，不会有跳转错误，编写的文本也很容易浏览。这意味着无需测试游戏中的所有分支，就能确保它们都能按预期工作。

使用编织还可以轻松修改选项，拆开故事并插入其他选项，而无需重新设计任何流程。

2.2 嵌套

上面展示的编织是非常简单的“扁平”结构。不管玩家选什么，他们都要经历相同的回合数才能从上到下。但是，有时某些选项需要深或复。因此，编织可以嵌套。

注意，编织的嵌套非常强大且紧凑，但你可能需要一些时间来适应！

选项收束均可

选项嵌套看下方的场景：

- “好吧，Poirot？谋杀还是自杀？”
*	“谋杀！”
* “自杀！”
-	Christie 女士片刻后放下手抄。台下的评委们都目瞪口呆。

提出的问题首选是“谋杀！” 或“自杀！”。如果 Poirot 宣布自杀，就没有其他事情可做了。但是在谋杀案中，还需要一个后续问题，“他怀疑是谁？”

我们可以通过一组嵌套的子选项来添加新选项。通过使用两个星号（**）而非是一个星号，告诉 INK 这些新选项是另一个选择的一部分。

-  “好吧，Poirot？谋杀还是自杀？”
	*	“谋杀！”
		“那么，你怀疑谁？”
		* *  “日本探长！”
		* *  “船长 Hastings！”
		* *  “我自己！”
	* “自杀！”
-	Christie 女士片刻后放下手抄。台下的评委们都目瞪口呆。

（用缩进显示嵌套关系是个不错的习惯，即使编译器不在乎这些。）

如果我们想向另一条路线添加新的子选项，可以按类似的方式做。

-  “好吧，Poirot？谋杀还是自杀？”
	*	“谋杀！”
	“那么，你怀疑谁？”
		* *  “日本探长！”
		* *  “船长 Hastings！”
		* *  “我自己！”	
	* “自杀！”
	“真的吗，Poirot？你确定吗？
		* *  “确定。”
		* *  “这很明显。”
-	Christie 女士片刻后放下手抄。台下的评委们都目瞪口呆。

现在，无论前面选择什么，最后都能收到 Christie 女士的出场。

有时不只是更多的选项，可能还有更多的剧情。我们可以用收束嵌套解决这个问题。

-  “好吧，Poirot？谋杀还是自杀？”
	*	“谋杀！”
	“那么，你怀疑谁？”
		* *  “日本探长！”
		* *  “船长 Hastings！”
		* *  “我自己！”	
    - -  “你一定是在开玩笑！”
    * *  “朋友，我是认真的！”	
    * *  “要是……”	
	* “自杀！”
	“真的吗，Poirot？你确定吗？
		* *  “确定。”
		* *  “这很明显。”
-	Christie 女士片刻后放下手抄。台下的评委们都目瞪口呆。

如果玩家选择谋杀，在这一分支后面会有两组选项，完全是“扁平”编织的。

收束是直观的，但它们的行为很难说出来：通常在选择之后，故事会找到下一个非更低级的收束，并移动下来。基本思想是：选项将故事的支线分开，并通过收束将它们重新合在一起。（因此，这被称为“编织”！）

嵌套可以很多层

上面我们使用了两层嵌套。事实上，你深入嵌套多少层都没有限制。

-	“讲个故事，船长！”
	*	“好吧，你们这些海狗。 有个故事...”
		* * 	“一个漆黑狂风暴雨的夜晚...”
				* * * 	“...船员们都很不安...”
						* * * *  “... 他们对船长说..."”
								* * * * *		“...给我们讲个故事，”
	*	“不，已经过了你们睡觉的时间。”
-	作为一个人，船员们开始打起哈欠。

这样下去，整个嵌套都会变得难以阅读或操作。因此，如果子选项变得笨拙，跳转到新针脚上是一种好习惯。

但至少在理论上，你可以把你整个故事都写成一个编织。

再看一个更长的例子：

- 我看着 Fogg 先生
*	... 我再也控制不住自己了。
	“先生，我们这次旅行的目的是什么？”
	“打赌，”他答道。
	* * 	“打赌！”[]我回应道。
			他点了点头。 
			* * * 	“但这确实很蠢！”
			* * *   “这太糟了吧？”
			- - - 	他又点了点头。
			* * *		“可是我们能赢吗？”
							“这正是我们要努力实现的。” 他回答道。
			* * *		“我猜，赌注很明智？”
							“两万英镑，”他回答得直截了当。
			* * * 	我当时没在问他别的[]，他礼貌得咳嗽了一声，也没在对我说什么。 <>
	* * 	“啊[。”]，” 我回应道，不确定我在想什么。
	- - 	之后， <>
*	... 但我什么也没说[]。<> 
- 我们在沉默中度过了这一天。
- -> END

这里验证了之前的哲学：编织提供了一种紧凑的方式，在有大量分支大量选择的同时，故事依然能顺利的从头走到尾！

2.3 编织定位 

有时候只是编织结构就足够了，但有时我们还需要更多的控制权。

在默认情况下，编织中的内容没有地址或标签，这意味着它们不能被跳转到，也无法对其进行测试。在最基本的编织结构中，选项会改变玩家经历；可一旦走过编织，这些经历就会被遗忘。

但如果我们想记录玩家的经历，我们可贴上“标签语法”(label_name)。

贴标签 (label_name)

任何层嵌套的收束都可以使用括号贴标签。-  (top)

贴上标签后，可以跳转至此或进行测试，就像结点和针脚一样。这意味着在编织中你可使用之前的语法来管理内容，同时保持清晰稳定的优点。

选项也可以用括号贴标签，就像收束一样。标签括号应位于条件之前。

这些地址也可用于条件测试中，这对测试“由其他选项解锁的选项”很有用。

=== meet_guard ===
卫兵在盯着你。

* 	(greet) [打招呼]
	“早。”
*	(get_out) “让开[。”]，” 你对卫兵说。

- 	“嗯，”卫兵回应道。

*	{greet} 	“天气不错哈？” // 当你选打招呼

* 	“咦？”[] 你回应道？

*	{get_out} [把他推到一旁] 	 // 当你威胁他时
	你把他推到一旁。作为礼尚往来，卫兵直接拔出了剑。
	-> fight_guard 			// 跳出编织

-	“嗯。” 卫兵给你一个小纸袋。“太妃糖？”

范围

在同一块编织内，你可只简单的写标签名称；到外面则需要写路径，像同个结点下的不同针脚：

=== knot ===
= stitch_one 
	- (gatherpoint) Some content.
= stitch_two 
	*	{stitch_one.gatherpoint} Option

或到另一个结点：

=== knot_one ===
-	(gather_one)
	* {knot_two.stitch_two.gather_two} Option
	
=== knot_two ===
= stitch_two 
	- (gather_two) 
		*	{knot_one.gather_one} Option

更多技巧

事实上，即使没有看到收束，INK 内的所有内容都是在编织中的。这意味着游戏中的所有选项都可贴标签，然后使用它的地址。特别的，这意味着你可以测试玩家为达到特定结果，选了哪个选项。

=== fight_guard ===
...
= throw_something 
*	(rock) [丢石头] -> throw
* (sand) [扔沙子] -> throw

= throw
你向卫兵扔了{throw_something.rock:一块石头|一把沙子}。

我们能用贴标签创建内部循环，这是询问NPC的标准模式。

- (opts)
	*	“我从哪能弄到制服吗？”[] 你询问快乐的卫兵。
		“当然，在储物柜那。”他笑着说。 “不过可能不太合身。”
	*	“告诉我安防系统。”
		“他很老，” 卫兵向你保证。 “就像古董一样老。”
	*	“这里的狗？”
		“很多很多。” 卫兵答道，并咧嘴一笑。 “也都是饿鬼。”
	//要求玩家至少问一个问题
	*	{loop} [问够了] 
		-> done
- (loop) // 在警卫厌烦前循环几圈
	{ -> opts | -> opts | } //序列可变文本控制卫兵是否厌烦
	他挠挠头，
	“好吧，不能整天只站着说话。”他说到。
- (done)
	你谢过警卫，便离开了。

选项也可以被跳转到，就好像选择了该选项一样。因此，显示的内容会忽略 [] 中的文本，并如果该选项是一次性选项，它将被用掉。

- (opts)
*	[做鬼脸]
	你做鬼脸，士兵就冲你来了！ -> shove

*	(shove) [把警卫推到一旁] 你把卫兵推到一旁，但他回来了。
*	{shove} [进入战斗] -> fight_the_guard

- 	-> opts

选项中可直接收束。注意下方第一个选项下二级收束并没其收束作用，而是方便第二个选项的跳转。

*	“还好吧，先生”[]我问。
	- - (quitewell) “挺好的，”他答道。 
*	“你填字游戏怎么样，先生？”[]我问。
	-> quitewell 
*	我什么也没说[]，我的主人什么也没说。
-	我们又感到了一次倍感亲切的沉默。

3. 变量与逻辑

到目前为止，我们已经根据玩家看到的东西，做出了条件文本与条件选项。

INK 还支持临时变量与全局变量，存储数字和内容数据，甚至故事流命令；逻辑功能也很齐全，并包含一些额外的结构，以帮助组织更复杂的故事结构。

3.1 全局变量 global variables

最强大的变量，储存游戏某些独特状态属性的变量，对每个故事来说可能都最有用的——从主人公口袋里的钱，到主人公精神状态的SAN值。

这种变量称为全局变量（global variables），因为可以从故事中的任何位置访问（包括设置和读取）它。（传统情况下，编程会试图避免这种情况，因为它可能会相互冲突。但故事有所不同，有一些事物贯穿始终，全局需要并一直存在。 ）

全局变量可以通过语句 VAR 定义在任何地方。给它们指定一个初始值，定义它们是哪种类型的变量：整数、浮点（十进制）、内容或故事的地址。

VAR knowledge_of_the_cure = false
VAR players_name = "Emilia"
VAR number_of_infected_people = 521
VAR current_epilogue = -> they_all_die_of_the_plague

我们可以控制全局变量以控制选项，并控制条件文本。方式与之前看到的类似。

=== the_train ===
	火车颠簸了一下。 { mood > 0:我觉得还好，没介意奇怪的颠簸|这超出了我所能承受的}。
	*	{ not knows_about_wager } “但是，先生，我们为什么要旅行？”[] 我问道。
	* 	{ knows_about_wager} 我考虑了我们有些离奇的冒险[]。这可能吗？

变量的值可用类似于序列和条件文本的语法显示出来，这在调试时也很有用：

VAR friendly_name_of_player = "Jackie"
VAR age = 23

我叫 Jean Passepartout，但朋友都叫我 {friendly_name_of_player}。 我{age}岁了。

你可能注意到，上面我们将变量称为能够包含“内容”而非“字符串”。这是有意的，因为在 INK 中定义的字符串能包含 INK ，尽管它始终会计算为字符串（很赞）。

VAR a_colour = ""

~ a_colour = "{~红色|蓝色|绿色|黄色}" 

{a_colour}

输出“红色，蓝色，绿色或黄色”中的一种颜色。注意，一旦输出了这样的内容，其值就是“确定的”。（量子状态崩溃。）因此，下面内容不会产生有趣的效果。（如果你希望这样做，请使用可变文本！）

呆子撞到了你，你眼冒金星， {a_colour}和{a_colour}闪烁。

这也是为什么 VAR a_colour = "{~red|blue|green|yellow}" 是不推荐的，它会影响到你的整个游戏。

3.2 逻辑运算 logic

显然，我们的全局变量并非为常量，因此我们需要一种语法来改变它们。

默认情况下，INK 中的任何文本都直接显示到屏幕上。因此我们用 ~ 来标记表示某行是在进行数值工作。

以下均是为变量分配值：

=== set_some_variables ===
	~ knows_about_wager = true	
	~ x = (x * x) - (y * y) + c
	~ y = 2 * x * y

以下是测试用的条件：

{ x == 1.2 }
{ x / 2 > 4 }
{ y - 1 <= x * x }

INK 支持数学四则运算（+，-，*和/），以及 % （或 mod ）进行求余。还支持 POW （幂）运算：

{POW(3, 2)} is 9. 
{POW(16, 0.5)} is 4.

还可以用 RANDOM 函数来生成随机整数。RANDOM 就像掷骰子，因此最小值和最大值都包括在内。（ temp 为临时变量）

~ temp dice_roll = RANDOM(1, 6) 
~ temp lazy_grading_for_test_paper = RANDOM(30, 75)  
~ temp number_of_heads_the_serpent_has = RANDOM(3, 8)

可用上文的 SEED_RANDOM() 进行测试。

INK 作为文字游戏引擎，奇怪的是并没有那么多字符串查询（string queries）方式。这有三种基本查询，相等，不相等和子字符串。以下全部返回 true：

{ "Yes, please." == "Yes, please." }
{ "No, thank you." != "Yes, please." }
{ "Yes, please" ? "ease" }

3.3 条件块 if/else

我们已经看到了用于控制选项和故事内容的条件内容，而 ink 还提供了与常规 if/else - if/else 结构等效的功能。

单纯使用 if —— 简单而有效的判断：

if 语法的判断条件，是从开始到现在为止产生的条件线索，而 {… } 语法表示正在测试某些内容。

{ x > 0:
	~ y = x -1
}

或者加上其他条件 else :

{ x > 0:
	~ y = x - 1
- else:
	~ y = x + 1
}

扩展 if/else - if/else 条件块：

上面的语法也可更改形式为另一种结构方式，类似于编程语言中的 switch 语句格式。

{ 
	- x > 0:
		~ y = x - 1
	- else:
		~ y = x + 1
}

在此格式基础之上进一步拓展，我们还可以实现 else-if 形式的条件判断：

{ 
	- x == 0:
  	~ y = 0
	- x > 0:
		~ y = x - 1
	- else:
		~ y = x + 1
}

（请注意，与其他所有内容一样，空格仅出于可读性考虑，没有语法含义。）

Switch Block （开关座：选择性判断语句）：

实际上 ink 的确有和其他编程语言中 switch 类似的语句。

{ x:
	- 0:	zero
	- 1:	one
  - 2:	two
  - else:	lots
}

示例：关联上下文内容

请注意，这里的判断条件除了可以使用变量之外，还可以使用玩家是否经历过结点作为条件，并且这种条件使用频繁，例如要做一些与当前游戏状态相关的内容：

=== dream ===
	{
		- visited_snakes && not dream_about_snakes:
			~ fear++
			-> dream_about_snakes

		- visited_poland && not dream_about_polish_beer:
			~ fear--
			-> dream_about_polish_beer 

		- else:
			// 清晨的梦只是梦境
			-> dream_about_marmalade
	}

此语法具有易于拓展的优势，优先选择使用此语法。

条件块中不仅限于逻辑运算

条件块可以用于控制故事内容以及发展走向：

我望着 Fogg 先生。
{ know_about_wager:
	<> “但你一定不是认真的吧？” 我诧异道。
- else:
	<> “但这次旅行一定是有一个原因，”我说。
}
他什么也没有回答，只是像昆虫学家研究他最新的发现那样，一丝不苟地研究他的报纸。

你甚至可以将选项放在条件块中：

{ door_open:
	* 	我大步走出车厢 [] 并且我仿佛听见我的主人在低声地自言自语。 			-> go_outside 
- else:
	*		我请求离开 [] 并且 Fogg 先生显得很惊奇。 	-> open_door 
	* 	我站起来打开了门 [] 。Fogg 先生似乎对这种小小的反抗并没有感到不安。 -> open_door
}

但是请注意，上面的示例中没有出现编织语法和嵌套语法不是偶然：为了避免嵌套带来的内容混淆，不允许在条件块中加入 gathers 收束点。

实现多种特殊功能的多行块 Multiline blocks

它们是另一种特殊的代码块，可以分别实现不同的功能：

// 顺序执行：根据每次的跳转依次执行，全部执行后持续执行显示最后一行
{ stopping:
	-   我进入了赌场。
	-   我又一次进入了赌场。
	-   我又一次走了进去。
}

// 随机洗牌：随机显示执行其中一行
在桌子上，我画了一张卡片。 <>
{ shuffle:
	- 	红心王牌。
	- 	黑桃王牌。
	- 	方块2。
		“你这次输了！”赌场庄家欢叫着。
}

// 循环执行：顺序显示执行，并循环如此
{ cycle:
	-   我屏住呼吸。
	-   我不耐烦地等着。
	-   我停顿了一下。
}

// 一次执行：顺序显示执行，每个分支只显示执行一次，全部显示执行后不再显示执行
{ once:
	-   我的运气好吗？
	-   我能赢吗？
}

{ shuffle once: 
	-	太阳很晒。 
	- 天气很热。
}

{ shuffle stopping:
	- 一辆银色宝马车呼啸而过。
	-	一辆亮黄色的野马车在转弯。
	- 这里有很多车。
}

=== near_north_pole ===
	~ temp number_of_warm_things = 0
	{ blanket:
		~ number_of_warm_things++
	}
	{ ear_muffs:
		~ number_of_warm_things++
	}
	{ gloves:
		~ number_of_warm_things++
	}
	{ number_of_warm_things > 2:
		尽管下雪了，但我还是感到无比舒适。
	- else:
		那天晚上我感觉比以往任何时候都冷。
	}

*	[Accuse Hasting]
		-> accuse("Hastings")
*	[Accuse Mrs Black]
		-> accuse("Claudia")
*	[Accuse myself] 
		-> accuse("myself")
		
=== accuse(who) ===
	"我控诉 {who}!" 波洛宣布。
	“真的吗？” Japp 回道。 “{who == "myself":你要这么做？|{who}？}”
	“为什么不可以？” 波洛回击道。

-> add_one_to_one_hundred(0, 1)

=== add_one_to_one_hundred(total, x) ===
	~ total = total + x
	{ x == 100:
		-> finished(total)
	- else:
		-> add_one_to_one_hundred(total, x + 1)
	}	
	
=== finished(total) ===
	“结果是 {total}！” 你宣布。
	高斯惊恐地盯着你。
	-> END

=== sleeping_in_hut ===
	你躺下闭上了眼睛。
	-> generic_sleep (-> waking_in_the_hut)

===	 generic_sleep (-> waking)
	你偶尔会做梦之类的。
	-> waking

=== waking_in_the_hut
	你重新站起来，准备继续你的旅程。

=== sleeping_in_hut ===
	你躺下闭上了眼睛。
	-> generic_sleep (waking_in_the_hut)

4.1 隧道（？）tunnels

INK 故事的默认结构是“扁平”的树状结构，分支又重新收束回一起，也许还有循环，但故事始终位于“某个位置”。

但是这种扁平结构会使某些事情变得困难：想象一个游戏，可能发生以下的相互作用：

=== crossing_the_date_line ===
*	“先生！”[] 我突然感到震惊。"我才意识到，我们已经穿过了国际日期变更线！"
-	Fogg 先生轻轻抬起了眉毛。“我已经调整过了。”
*	我擦了擦额头上的汗水[]。松了口气！
* 我轻轻的点头[]。他当然会做的。
* 我在心里抱怨[]。 我又被小看了一次。

…但它可能发生在故事中的几个不同地方。我不想为不同的地方写相同内容，但是当内容完成后，它还需要知道返回到哪里。我们可以使用参数来做到这一点：

=== crossing_the_date_line(-> return_to) ===
...
-		-> return_to 

...

=== outside_honolulu ===
我们到了Honolulu 最大的岛。
- (postscript) 
		-> crossing_the_date_line(-> done)
- (done)
		-> END 

...

=== outside_pitcairn_island ===
船在水上驶向小岛。
- (postscript) 
		-> crossing_the_date_line(-> done)
- (done)
		-> END

这两个位置都调用并执行相同的故事片段，一旦完成，它们就会回到下一步要去的地方。

但如果这个“故事的部分”更复杂怎么办？如果跨越多个结点怎么办？使用上面的方法，我们必须不断地将“ return-to”参数从一个结点传递到另一个结点，以确保我们始终知道该返回的位置。

因此，INK 把跳转和新功能结合到起来加语言中，其功能类似于子程序，称为”隧道”（tunnels）。

隧道的语法看起来很像跳转，末尾还有另一个跳转：

-> crossing_the_date_line ->

这意味着运行一个“crossing_the_date_line 的故事”，然后从这继续。

在隧道内部，语法展示进行了简化：用 ->-> 语句结束隧道，实质上意味着“继续”。

=== crossing_the_date_line === 
// 这里是隧道！
...
- 	->->

注意，隧道结点和普通的结点不同，编译器将不会检查隧道是否真的以“->->”语句结尾，除非在运行时。因此，您需要仔检查进出隧道的跳转。

隧道可串在一起，也可在普通跳转上：

... 
// 这里运行了隧道，然后跳转到 done
-> crossing_the_date_line -> done
...

... 
//这里运行了第一个隧道，第二个隧道，然后跳转到 done
-> crossing_the_date_line -> check_foggs_health -> done
...

隧道可以嵌套，因此以下内容也行：

=== plains ===
= night_time 
	脚边是深色柔软的草丛。
	+	[休息]
		-> sleep_here -> wake_here -> day_time
= day_time 
	到了该动身的时间了。
	
=== wake_here ===
	你随太阳一同醒来。
	+	[吃些东西]
		-> eat_something ->
	+	[该动身了]
	-	->->

=== sleep_here ===
	你躺下并闭上双眼。
	-> monster_attacks -> 
	接着该睡觉了。
	-> dream ->
	->->