引言
Golden Board 是一条二进制消息,旨在向一个没有共同语言、文化或国际象棋先验知识的未知接收者教授国际象棋。它从教授读取自身内容所需的格式开始。
完整项目代码和文档可在 GitHub 上获取。
本指南遵循这一过程:从比特中恢复数字,用它们重建图片和交互,然后了解这些图片如何描述国际象棋。一盘完整的对局连接了各个层次,从其物理比特到最终显示的棋局。
欢迎随时反馈。
在深入之前,我想澄清关于这个项目的几点。
它看起来是什么样的?
简而言之,Golden Board 是一个 4,194,304 比特的序列,即 512 KiB 的 1 和 0。这个数字暗示将它们排列成一个 2,048 × 2,048 的正方形。
里面有什么?
前 64 行包含 32 幅图,每幅 64 × 64 个单元格。它们共同构成了引导部分:它教授如何读取消息的其余部分。它与国际象棋无关,可用于解码其他结构化消息。
下方的有效载荷包含可视化国际象棋课程、带反馈的练习、完整对局,以及查找、检查和显示它们所需的信息。
这个想法从何而来?
我从面向未知智能的消息中汲取了灵感,例如旅行者金唱片、Lincos 等。
但 Golden Board 不分享科学知识或艺术作品,而是教授国际象棋。
为什么是国际象棋?
两个原因。
第一,一小组规则开启了广阔的可能性、思想和美的世界。
第二,对局可以分享的不仅仅是知识:它提供了对人类心智的一瞥。
我如何测试它?
我使用 LLM 作为未知接收者的替代品进行试验,测试用原始比特、解码内容以及不同程度的辅助来解码和理解。
正确恢复字节和理解课程是分开的测试。这些模型已经懂国际象棋,因此仅凭正确的国际象棋答案不能证明是消息教会了它们。这些试验帮助识别了歧义并改进了设计;它们并不能证明未知智能会理解它。阅读试验记录。
我如何选择对局?
没有任何一组 64 盘对局是完整的。
我选择对局是因其国际象棋内容:精彩的进攻、出人意料的弃子、巧妙的防守、安静的战略和优美的残局。PGN 选集包含 64 盘对局,而二进制消息省略了姓名、日期和赛事。
这一切是为了什么?
分享你所爱之物有一种特殊的快乐。
我们能向一个对我们一无所知的文明分享什么?他们可能已经了解我们的科学,或者缺乏理解我们艺术的背景,但国际象棋可以从零开始教授,揭示数百年的人类想象力、错误和才华。
最有可能的是,永远不会有人收到这条消息。但即使只有微小的机会,有人可能发现一个带有像 Bf5 这样着法的棋局,也让这一切值得一试。
你能在此基础上构建吗?
可以。与国际象棋无关的引导部分、二进制格式和 Python 工具为在没有共同语言或文化的情况下教授其他科目提供了起点。开发者可以改编该系统;研究人员可以利用这些试验来调查什么有效、什么失败以及原因。源代码和文档。
如何阅读本指南
在源图中,每个单元格显示一个比特:黑色代表 1,白色代表 0。解码后的图片是从存储的数据重建的,而不是从源正方形中裁剪的。
这里的颜色、细灰色参考线和标签是为了让图片更易读而添加的。它们不是原始消息的一部分。
预期的接收者可以在没有视觉辅助的情况下,使用边界框、固定序列长度和其他先前学到的模式来推断这些排列。
下图中的框架是一个示例;其内容将在后文解释。蓝色区域覆盖一行数据及其下方的小标记。橙色区域标出其左侧的小数字。绿色区域覆盖一个完整的带框列表。灰色参考线便于清点各个比特位。
将鼠标悬停在彩色短语上可只保留与之匹配的高亮。将鼠标悬停在图片上可隐藏所有视觉辅助。
读取数字与图片
接收方从一串干净的比特序列或一个采样方阵开始,并假定其能够计数、识别模式并编写简单程序。从信号或物理对象中获取这些单元是另一个独立问题。
第一项任务是从比特中恢复图片与交互。接收方随后可以利用这些显示内容来学习国际象棋。引导部分通过示例建立读取规则;接收方提供一个遵循这些规则的程序。消息携带的是供该程序解释的数据,而非可执行代码。
引导部分是下方视图顶部的那条窄带。其下方的有效载荷区域包括末尾的未使用空间。
头部显示顺序与相关分组
在查看每幅图内部之前,先用其头部在条带中定位。每个帧都重复相同的角标记。其顶行将填充单元计数与一个二进制数字配对,给出其全局编号,1–32。再往下两行的第二对则计数相关分组内的步骤。该局部计数在每个分组中重新开始;独立帧则将该行留空。
比较这四个头部。帧 6 是全局第六个,也是其相关分组中的第二个。帧 3 独立存在:
帧 1:全局 1(00000001),分组步骤 1(00000001)。
帧 2:全局 2(00000010),分组步骤 2(00000010)。
帧 3:全局 3(00000011),无局部计数器。
帧 6:全局 6(00000110),分组步骤 2(00000010)。
下方的角部裁剪图展示了同一接收模式在四个旋转角度下的样子:
四分之一转
四分之三转
重复出现的角提示了一个可以尝试的方向。递增计数、尺寸和校验和用于检验其是否保持一致。仅凭这个角并不能证明方向,也不能证明哪个接收状态应代表 1。
32 帧中的第 1 帧:通过计数读取数字
二进制数字将比特模式与数量联系起来。这第一帧通过将数字与可计数的单元配对来建立这种联系。
左侧条纹包含 0、1、2、3、4、7、8 和 15 个填充单元。与每条条纹相对,上方的四位数字给出相同的数量:空条纹对应 0000,两个填充单元对应 0010。下方的八位数字以前导零重复这些数量。
32 帧中的第 2 帧:识别每个比特位的位置
一个填充比特根据其位置贡献不同的量值。将其向左移动一位会使该贡献翻倍。这一帧将每个单比特模式与其位置编号配对。
左列从 00000001 开始,并在每一行将其唯一的填充位置向左移动一位,最终以 10000000 结束。右列从最右侧比特开始,将这些位置从 1 计数到 8。每一对水平相邻项属于同一组。
每个字段在其数据行周围都有黑色边框和白色内嵌边。即使大多数位置为空,边框也固定了完整宽度。因此,八位模式保持在一列中,而其四位位置编号保持在另一列中。
32 帧中的第 3 帧:读取图片的尺寸与补集
图片既包括其填充位置,也包括其空位置。当比特被反转时,其尺寸仍保持矩形不变。
左侧图片有三行五列。在其第一行中,第一个位置为空,第二个位置为填充。
正确的图保留同样的十五个位置,但交换了填充与空白。左图下方的两个数字是 3 和 5:先是行数,然后是列数。两个数字都止于图片的右边缘。它们统计的是图片位置,而不是用于绘制方块的源单元格。
第 4 帧,共 32 帧:确立行顺序
如果没有共同的阅读顺序,同一串数值可能产生不同的图片。带编号的排列使顺序变得明确。
上方的排列第一行是 1、2、3,第二行是 4、5、6。下方的序列重复 1 到 6。每一行从左到右读完后再继续下一行:这就是行主序。
第 5 帧,共 32 帧:将八个比特组成一个字节
字节是按固定顺序排列的八个比特。这一帧将一个紧凑的组与其八个单独的比特位置对应起来,确立后续长度和校验所使用的单位。
上方的紧凑模式是 00110101。其下方的箭头指向八个独立的方框,其中包含相同顺序的相同比特。读取每个方框中心的那一格:第一个是空的,而第三个是填充的。
那一行下方的两个数字是 00000001 和 00001000:一行,八个比特位置。上方的紧凑组是一个字节;展开的行显示其八个比特。它们共同确立了一个字节 = 八个比特。下半部分对 00001011 重复了这一对应关系。
第 6 帧,共 32 帧:组合高字节与低字节
一个跨越多个字节的数需要字节序。交换其高字节和低字节会改变其值,即使每个字节仍包含相同的比特。
每一行在左侧重复一个十六位数,中间是其前八个比特,右侧是后八个比特。每一行都有自己的边界,因此完全为零的高字节或低字节仍作为字段可见。在第五行,0001001000110100 拆分为 00010010 和 00110100:十进制 18 和 52。
第一个字节计量 256 的组数;第二个字节计量剩余的单位。该行表示 18×256 + 52 = 4,660。下一行反转了字节,表示 52×256 + 18 = 13,330。这是高字节在前的顺序。记法 u16 表示两字节的非负整数;u32 表示四字节的非负整数。
第 7 帧,共 32 帧:读取尺寸和已用载荷长度
接收方需要定位载荷,并知道剩余方形区域中有多少需要读取。这四个度量将引导区、已用数据和未用保留区区分开来。
从上到下,各字段给出方形边长 2,048;第一个载荷行 64,从 0 开始计数;字节宽度 8 比特;以及已用载荷长度 506,509 字节。前三个字段各为十六比特;最后一个为三十二比特。它们的右边缘对齐,因此更宽的最后一个字段向左延伸得更远。
从第 64 行开始,在每一行内从左到右读取,然后继续下一行。每八个单元格组成一个字节,最高值比特在前。恰好恢复所声明的字节数。第 32 帧展示了已用长度与剩余容量的关系。
检查恢复的字节
接收方在信任恢复出的课程和对局之前,需要的不仅仅是看起来合理的数字。错误的方向、比特解释或字节分组仍可能产生数值。Golden Board 包含校验,使接收方在使用内容之前能够拒绝不一致的读取结果。
内容被组织为文档:图片定义、数值数据以及显示或交互指令的集合。每个文档的字节位于一个称为节的受校验块中。其头部标识该文档并给出其字节长度。该长度既定位末尾的校验,也定位下一节的开头。
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教下棋
正文: 一个节还存储校验和,即根据其标识字段和内容计算出的值。创建消息的程序根据原始字节计算该值。接收方对恢复出的字节重复计算,并将结果与存储的校验值比较。不匹配则拒绝该次读取。匹配支持这些字节的一致性;它不修复它们,也不确立其含义已被理解。
以实际载荷中的第 2 节为例。其前六个字节构成一个头部:文档的编号(称为其 ID)和文档的字节长度。文档本身紧随其后,然后是存储的校验和。计算覆盖头部和每个文档字节,并在存储的校验值之前停止。
第 2 节 · 93,027 字节
头部 · 6 字节
长度:0 1 107 89 → 93,017
前八个字节:214 57 0 64 0 151 1 68
……然后是另外 93,009 个字节
计算输入:头部 + 完整文档 = 93,023 字节
存储的校验和 · 4 字节
182 147 233 40
不在计算的输入之内
根据全部 93,023 个输入字节计算得出:182 147 233 40。四个存储字节匹配。
Golden Board 使用 CRC-32C 进行此计算。接下来的图先用一个输入字节讲解它,然后将相同方法应用于完整的一节。直接目标是从相同的比特中复现发送方的校验值。
第 8 帧(共 32 帧):定义 XOR 与相等
校验和需要一种组合比特的方式和一种测试一致性的方式。本帧使用所有可能的输入对来定义这两种运算。
左侧的输入列列出 00、01、10 和 11。它们的结果是 0、1、1、0:当输入不同时,XOR 产生 1。右侧的输入列重复这些组合;它们的结果是 1、0、0、1:当它们一致时,相等产生 1。
第 9 帧(共 32 帧):右移并保留移出的比特
右移将每个比特向右移动一个位置。本帧将移位后的行与从其右边缘离开的比特分开;校验和计算使用这两个结果。
在上面的示例中,输入字段以 00110101 结尾。其下方移位后的字段以 00011010 结尾。一个零从最左侧进入,单独的移出比特框中包含从输入右边缘离开的 1。
其他示例以不同的输入模式重复此布局。在最下面的示例中,输入以 0 结尾,移出比特框的中心为空。即使结果为零,其边框也保留结果的位置。
第 10 帧(共 32 帧):识别校验和的固定模式
发送方和接收方需要相同的常量才能得到相同的校验和。以下计算使用此处显示的模式。
顶部字段包含三十二个 1。中间字段包含另一个三十二位模式。底部字段重复整个中间模式,并在前面添加一个 1。这些字段在其右边缘对齐,使添加的比特在左侧可见。
下方字段是 CRC-32C 多项式的两种形式,即标识此 CRC 的固定模式。底部形式包含其前导比特。保留中间模式,以便与第 12 帧中各状态之间的变化进行比较。
| 含义 | 比特 |
|---|---|
| 三十二个 1 | 11111111 11111111 11111111 11111111 |
| 前向多项式 | 00011110 11011100 01101111 01000001 |
| 带前导项的多项式 | 1 00011110 11011100 01101111 01000001 |
第 11 帧(共 32 帧):启动校验和并与一个字节进行 XOR
校验和保持一个不断变化的 32 位工作模式,称为其状态。将一个输入字节与该模式组合,使该字节影响最终的校验值。本帧显示起始状态、第一个字节以及组合它们的结果。
一个共享的外框将两个输入分组:上方的全 1 状态和下方的输入字节。状态有四个八位带。输入是 00110101,即第 5 帧中展开的模式,对齐在最右侧的带下方。
将 Frame 8 的 XOR 规则应用于那八个对齐位置,得到 11001010。其余三个状态带没有需要改变的输入位,保持全为 1。向下的箭头从分组输入指向这个四带结果。该结果启动了接下来展示的八个比特轮次。
第 12 帧(共 32 帧):走完所有八个比特轮次
接收方必须能够从当前校验和状态计算出下一个校验和状态。本帧提供了一个完整的演算序列,以便对照每一次状态转换检验该规则。
右侧的数字标注了工作模式,从状态 0 到状态 9。第一行是起始模式;第二行是 Frame 11 中的字节 XOR 结果。其最后一位是 0。将该行右移,恰好得到状态 2。
状态 2 的最右位是 1。将整个模式右移。下方对比中的顶部青色行就是计算出的移位结果。引导数据还提供了下一个结果,即状态 3,显示在中间的玫瑰色行中。将二者比较,就能看出本轮所做的额外改动。
将这两行中对应的位置对齐。在青色列中,这些比特不同:必须翻转移位结果中的这些位,才能得到所提供的那个结果。在每个不同的位置填入 1,在每个相同的位置填入 0。这就是在 Frame 8 中学到的 XOR 比较。其最下面一行是固定的反馈模式:一张标明哪些位置需要翻转的映射图。
我们利用本帧提供的那个结果来识别出该模式。要向前计算这一轮,先右移状态 2,再将移位结果与反馈模式做 XOR。这些翻转就产生了状态 3。移出的 1 选择了这个反馈步骤,因此该比特在离开右边缘后仍会继续影响校验和。
剩下的六轮使用同样的规则。移位前先检查最右位:移出的是 0 时只需要移位;移出的是 1 时还需要固定的 XOR 模式。字节 XOR 步骤之后共有八轮,结束于状态 9。下表转录了每一个提供的状态,并注明了产生该状态的操作。
| 模式 | 比特 |
|---|---|
| 状态 2 的计算移位结果 | 00111111 11111111 11111111 11110010 |
| 状态 3,由本帧提供 | 10111101 00001001 11000100 10001010 |
| 反馈模式:不同的位置 | 10000010 11110110 00111011 01111000 |
| 含义 | 比特 | 产生该行的操作 |
|---|---|---|
| 状态 0:起始模式 | 11111111 11111111 11111111 11111111 | 全 1 的起始状态 |
| 状态 1:字节 XOR 之后 | 11111111 11111111 11111111 11001010 | 与输入字节做 XOR |
| 状态 2:第 1 轮之后 | 01111111 11111111 11111111 11100101 | 右移 |
| 状态 3:第 2 轮之后 | 10111101 00001001 11000100 10001010 | 右移,然后与固定模式做 XOR |
| 状态 4:第 3 轮之后 | 01011110 10000100 11100010 01000101 | 右移 |
| 状态 5:第 4 轮之后 | 10101101 10110100 01001010 01011010 | 右移,然后与固定模式做 XOR |
| 状态 6:第 5 轮之后 | 01010110 11011010 00100101 00101101 | 右移 |
| 状态 7:第 6 轮之后 | 10101001 10011011 00101001 11101110 | 右移,然后与固定模式做 XOR |
| 状态 8:第 7 轮之后 | 01010100 11001101 10010100 11110111 | 右移 |
| 状态 9:第 8 轮之后 | 10101000 10010000 11110001 00000011 | 右移,然后与固定模式做 XOR |
Frame 12 的各次状态转换所揭示出的固定 XOR 模式,就是 Frame 10 中间那个模式按比特顺序反转读取的结果。这将右移计算与那里展示的多项式联系起来。它改变了对该常量的解读;各字节本身仍保持 Frame 6 确立的高字节在前的顺序。
第 13 帧(共 32 帧):完成并存储校验和
最后一个运行状态通过一次最终的 XOR 变成存储的校验和。接收方必须将那个最终值与计算过程中使用的中间状态区分开来。
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教会下棋
正文: 这里重复了 Frame 11 的分组输入布局。将八轮之后的状态与它上方的全 1 状态做 XOR。箭头指向结果,其四个位段读作 87 | 111 | 14 | 252。
第二个箭头指向四个分别划定边界的字节。每个字节都直接位于结果对应位段的正下方,且具有相同的八个位。从左到右读取保持高字节在前的顺序。这是对单个输入字节 00110101 的校验;下一帧将把计算出的校验与存储的校验进行比较。
32 帧中的第 14 帧:比较计算出的校验与存储的校验
通过将计算值与存储值进行比较,校验和就变成了完整性检查。这三个案例展示了同一个相等性测试先成功、再失败、然后又成功。
在顶部案例中,输入字段包含 00110101,读作 53。上行的计算校验与其下方的存储校验一致。因此右侧的单比特相等性字段包含 1,使用与 Frame 8 相同的带框比特约定。
中间案例将输入改为 00110100,但保留了针对较早模式的校验。两个校验不同,因此相等性字段包含 0。底部案例使用 00001011 及其自身的校验,返回 1。这些是对字节模式的校验,而不是对用于打印其十进制读数的字符的校验。
查找节与文档
接收方现在可以读取数字并复现校验和。下一项任务是找到每一节的边界,并恢复其中的文档。节是带校验的存储包装;文档是要显示和使用的事物的集合。
这些事物以记录的形式存储。每条记录都有一个种类、一个称为 ID 的数字名称,以及它自己的内容。例如,一条记录可以定义一个小图片,另一条记录可以通过 ID 引用该图片。将定义保存在一处可以让许多显示复用它。ID 在消息创建期间分配并存储在数据中;接收方读取它们,而不是从形状推断它们。它们的作用域是一个文档。
清单列出了必须恢复的文档,以及每个文档可以在哪些记录中被打开。这些起始记录就是它的条目。它们导向一个图片序列或一个交互。条目是记录的 ID,而不是它的字节地址。
为了教授这些关系,引导程序包含一个完整的、326 字节的小型示例文档。它的简单图片和响应在下棋出现之前就演练了该格式。接下来的图描述了这个示例,它被携带在条带内部。条带下方的完整五文档载荷使用相同的规则。
32 帧中的第 15 帧:划分一个完整的节
这一帧将节划分为字节范围。它的头部声明后面跟随多少正文数据,因此接收方可以找到校验和下一节。
每一行有三列:起始地址、字节长度,以及该范围之后的第一个地址。ID 行读作 0、2、2;正文长度字段行读作 2、4、6。这两个字段构成六字节头部。正文行读作 6、326、332,后面跟着校验行:332、4、336。
因此该节为 336 字节:六个头部字节、326 个正文字节和四个校验字节。这些三元组描述的是布局;它们不是存储在头部中的额外字段。正文长度值只计正文。ID 命名该节;它的含义由下面的清单示例确立。
| 含义 | 位 | 十进制 |
|---|---|---|
| ID 范围 | 00000000 00000000 │ 00000000 00000010 │ 00000000 00000010 | 0 │ 2 │ 2 |
| 正文长度字段范围 | 00000000 00000010 │ 00000000 00000100 │ 00000000 00000110 | 2 │ 4 │ 6 |
| 正文范围 | 00000000 00000110 │ 00000001 01000110 │ 00000001 01001100 | 6 │ 326 │ 332 |
| 存储校验范围 | 00000001 01001100 │ 00000000 00000100 │ 00000001 01010000 | 332 │ 4 │ 336 |
32 帧中的第 16 帧:将载荷地址映射到方格单元
字节地址必须能引导回方格中的位置。这一帧将每个地址连接到物理行和列。
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教会下棋
正文: 每个方框的顶行给出从载荷起始处算起的字节偏移,以及该字节内的位索引。紧随其下的是方格行号与方格列号。这些是读取存储位的地址,因此从零开始;位 0 是一个字节中最左边的第一位。而 Frame 2 中的标签则从右往左计数二进制位,从一开始。
每个物理行容纳 2,048 ÷ 8 = 256 个字节。因此第一组 256 个字节填满第 64 行:字节 0 从第 0 列开始,字节 1 从第 8 列开始,字节 255 结束于第 2,047 列。字节 256 从下一行即第 65 行的第 0 列开始。这些边界情况出现在第三、第四和第五个方框中。
要定位另一个字节,先数完整的 256 字节组,以确定从第 64 行向下移动多少行。在剩余的那一组内,每字节移动八列,再加上它的位索引。这就是为什么区段边界不必与物理行边界重合。
Frame 17 of 32:保留矩形与空行
尺寸保留一幅图像的完整矩形,包括空白位置和完全为空的行。
对于左上角矩阵,其上方第一个数字是 00000010:两行的高度。下一个数字是 00001000:八列的宽度。其他方框使用同样的顺序,得到三行五列、一行七列和两行八列。
右下角矩阵的第二行完全为空。它的八个位置仍然属于这幅图像。无论是空行还是空白列,都不能通过裁剪到可见的黑色形状而移除。
Frame 18 of 32:命名对象并统计其引用
一个对象可以被赋予一个数字名称,然后通过重复该名称来引用它。这一帧将名称、引用计数和引用列表分开,每个目标都在使用之前先被引入。
每一行有三个部分:左边是八位的名称,中间是八位的引用计数,右边是一个带边框的列表。名称并不指定对象的大小或其物理地址。
顶行以 00000110 开头,读作 6。该模式命名第一个对象。其计数为 00000000,因此引用列表为空。第二行给出另一个名称 00000111 即 7,同样没有引用。
第三行以 00001000 开头,读作 8。其计数 00000001 表示后面有一个引用:00000110,重复了第一行的名称。
底行以 00001001 开头,读作 9。其计数 00000010 表示后面有两个引用:00000111 和 00001000。它们分别到达第二和第三个对象。再顺着第三个对象自己的引用,就到达了第一个。计数与列表长度同步递增:零、零、一、二。
Frame 19 of 32:检查缩略图的实际区段
这一帧给出缩略图区段的实际字段,以及其校验和所覆盖的确切范围。它把存储的校验值放在该范围之后,置于其自身计算之外。
左侧三个四位的数字给出其旁边条带的字节数:0010、0100、0100 分别表示两字节、四字节和四字节。数据下方的小标记标识每个字节的起始位置。这些黑色数字和标记属于原始绘图。它们描述如何读取其条带;它们不会为区段增加字节。
前两个数据条带给出区段 ID 1 和正文长度 326。第三个条带包含四个存储的校验和字节:255 64 93 120。
上方的有界范围读作 0 | 332 | 332:从字节零开始,校验 332 个字节,在地址 332 之前停止。箭头下方的结果重复了存储校验值的各位。下方的有界范围是 332 | 4 | 336,定位这四个校验字节在被覆盖范围之后的位置。
| 含义 | 位 | 十进制 |
|---|---|---|
| 区段 ID | 00000000 00000001 | 1 |
| 正文字节长度 | 00000000 00000000 00000001 01000110 | 326 |
| 存储的校验和字节 | 11111111 01000000 01011101 01111000 | 255 64 93 120 |
| 覆盖范围 | 00000000 00000000 │ 00000001 01001100 │ 00000001 01001100 | 0 │ 332 │ 332 |
| 存储校验范围 | 00000001 01001100 │ 00000000 00000100 │ 00000001 01010000 | 332 │ 4 │ 336 |
将校验和跨越字节序列传递
覆盖范围包含六个头部字节和 326 个正文字节。从全一状态开始,将第一个字节 XOR 进其低八位,并执行八轮。将下一个字节 XOR 进结果状态,再执行八轮。继续处理每个覆盖字节,然后最后应用一次全一 XOR。每个区段重新开始此过程。为每个字节单独计算一个完成的校验和会丢失连接序列的运行状态。帧 29 提供了本工作区段的所有字节。
第 20 帧(共 32 帧):读取完整的清单区段
清单列出了完整消息所需的文档区段。这里它包含一个文档:工作缩略图。
六字节头部声明区段 ID 0 和正文长度 18。接下来的十八个字节是清单正文,随后是其四个校验和字节,113 28 238 100。它们共占用 28 个字节:三个完整的八字节行和第四个行的一半,从本地行 31 开始。
第一行包含头部和正文的开头。行断点是呈现边界,而非区段分隔符。ID 0 标识清单;正 ID 标识文档。这个小清单只列出了引导程序内的工作文档。
第 21 帧(共 32 帧):读取清单计数和条目引用
清单标识要恢复的文档以及可以开始读取它的记录。此帧将帧 20 的清单正文展开为各个字段。
左侧的四位字节计数使用帧 19 的约定。例如,第一个带旁的 0010 表示其值占用两个字节。该带中的值为 1:一个文档。
前三个数据带给出文档计数 1、文档区段 ID 1 和文档长度 326。下一个带包含 255 64 93 120,即该文档区段的预期校验和字节。它们与帧 19 中的检查匹配。
条目计数为 2。它给出条目 ID 512 和 257 的框选列表长度。每个条目 ID 占用两个字节,正如其各自的左手计数所确认。这些 ID 命名记录,而非字节地址;接下来的帧定义这些记录。
| 含义 | 位 | 十进制 | 字节 |
|---|---|---|---|
| 文档计数 | 00000000 00000001 | 1 | 2 |
| 文档区段 ID | 00000000 00000001 | 1 | 2 |
| 文档字节长度 | 00000000 00000000 00000001 01000110 | 326 | 4 |
| 预期文档区段校验和字节 | 11111111 01000000 01011101 01111000 | 255 64 93 120 | 4 |
| 条目计数 | 00000000 00000010 | 2 | 2 |
| 第一条目 ID | 00000010 00000000 | 512 | 2 |
| 第二条目 ID | 00000001 00000001 | 257 | 2 |
读取五种记录类型
找到文档的字节尚未告诉接收者如何绘制其图片或进行其练习。其记录将这项工作分为五种,均使用相同的命名记录格式。
字形存储一个小矩形位图。显示帧将字形 ID 放置到更大的网格中,因此同一个位图可以在许多单元格中重复使用。帧单元格选择整个字形;它不同于源消息单元格或字形内的一个像素。“第 N 帧(共 32 帧)”继续表示引导程序绘图;编号的显示帧记录属于文档。
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教会下棋
正文: 一条 trace 从一个 frame 出发,把存储的改动应用到指定索引的单元格上。这样,这条消息就能展示一幅变化的图,或者重放一局棋,而不必把每一幅完整画面都单独存下来。一个 page 把显示内容与选项、可接受的回答、反馈目标以及链接组合在一起。一个 table 把数字和一条 trace 并排存储;课程会讲解这些数字的含义。
这份完整的文档共有 15 条 record:三个 glyph、四个 display frame、一条 trace、一个 table 和六个 page。它的 header 把 page 512 和 trace 257 指定为 entry。每条 record 都以它的 kind、ID 和内容长度开头;record 自身的内容也被称为它的 payload。这个长度不包含 record 的七字节 header。在解析它们的引用之前,请先读取所有 record:一个目标可能出现在文档中更靠后的位置。
player 是接收方的程序,用来解释这些 record,并执行它们的显示和交互操作。一个 frame 规定每个单元格里放哪一幅位图。本指南显示大小相同的 tile,tile 内是放大的 glyph;tile 的大小和间距属于呈现方式的选择。编码中的尺寸分别统计 frame 的单元格数和 glyph 的像素数。
Frame 22 of 32:读取文档 header 和矩形 glyph
一份 document 提供起始 record 和可复用的位图。这个 frame 先定义它的 header,然后定义两条 glyph record。
最上面的五个数据带包含标记字节 214、57、entry 数量 2、record 数量 15,以及 entry ID 512 和 257。左侧的小标尺按字节计数。每个数据带下方的标记指示字节的起始位置。两者都是描述这些数据带的原始黑色标记;它们都不为序列化后的文档贡献任何字节。表格的 Bytes 列记录了左侧的宽度。
中间那组和空矩形定义 glyph 0;底部那组和带图案的矩形定义 glyph 1。每条 record 都以 kind 1、一个两字节 ID 和一个四字节 payload 长度开头。它的三个 payload 字节给出两行、三列和一个打包的位图。
Glyph 0 的位图字节是 00000000,读作 0。Glyph 1 的是 11010100,读作 212。它的前六位构成 110 / 101;两个零填充位补足这个字节。两个矩形都保留全部三列,包括白色像素。
| Meaning | Bits | Decimal | Bytes |
|---|---|---|---|
| Document marker bytes | 11010110 │ 00111001 | 214 │ 57 | 2 |
| Entry count | 00000000 00000010 | 2 | 2 |
| Record count | 00000000 00001111 | 15 | 2 |
| First entry ID | 00000010 00000000 | 512 | 2 |
| Second entry ID | 00000001 00000001 | 257 | 2 |
| Record kind | 00000001 | 1 | 1 |
| Record ID | 00000000 00000000 | 0 | 2 |
| Payload byte length | 00000000 00000000 00000000 00000011 | 3 | 4 |
| Glyph rows | 00000010 | 2 | 1 |
| Glyph columns | 00000011 | 3 | 1 |
| Packed glyph mask | 00000000 | 0 | 1 |
| Record kind | 00000001 | 1 | 1 |
| Record ID | 00000000 00000001 | 1 | 2 |
| Payload byte length | 00000000 00000000 00000000 00000011 | 3 | 4 |
| Glyph rows | 00000010 | 2 | 1 |
| Glyph columns | 00000011 | 3 | 1 |
| Packed glyph mask | 11010100 | 212 | 1 |
四位的宽度标尺 0010 计为两个字节。数据 11010110 00111001 是文档标记字节,读作 214 和 57。数据下方的标记指示每个字节的起始位置。
以字节表示的文档 header
文档以这十个字节开头,用十进制表示,并按字段分组。两字节整数采用高字节在前的方式存储。
214 57 0 2 0 15 2 0 1 1
band map 标出了这个序列中的各个字段。每个 entry ID 占两个字节:2 0 是 512,1 1 是 257。
Kind 1:可复用的位图
Glyph record 1 占据微缩字节 20–29:1 0 1 0 0 0 3 2 3 212。它的七字节 header 给出 kind、ID 和 payload 长度。它的三个 payload 字节给出两行、三列和掩码 212,即 11010100。前六位构成 110 / 101;两个零填充位补足这个字节。
字形 0 是一条单独记录,掩码全为零。两个字形都保留完整的二行三列尺寸。它们的 ID 是名称,显示帧用这些名称来选择这些形状。因此,一个包含 1 的帧单元选择的是字形 1;它不会把整个单元变成一个实心方块。
图表:Glyph 0
图表:Glyph 1
第 23 帧(共 32 帧):用字形 ID 构建帧
显示帧通过在索引位置放置可复用的字形来构建更大的图像。它还可以为位置分配名称,后续练习让接收方选择这些位置。
记录头标识 kind 2、ID 256 和负载长度 18。两个尺寸字段指定两行三列。六个字形 ID 为 0,1,1 / 1,0,1,按每行读取。查找这些 ID 即得到左下角的图。左侧的标尺给出每个字节带的宽度。
字形 ID 能放进一个字节,所以这六个帧单元占六个字节。记录头仍然使用两字节 ID。引用的宽度取决于承载它的字段。
在这些单元之后,一个计数 2 引入两个选择定义。每个定义包含一个区域 ID,后跟一个单元索引。第一个定义是 10 | 0:区域 10 选择单元 0,即左上位置。第二个定义是 20 | 5:区域 20 选择单元 5,即右下位置。匹配的高亮把每一对连接到其图像位置和索引框。
| 含义 | 位 | 十进制 | 字节 |
|---|---|---|---|
| 记录类型 | 00000010 | 2 | 1 |
| 记录 ID | 00000001 00000000 | 256 | 2 |
| 负载字节长度 | 00000000 00000000 00000000 00010010 | 18 | 4 |
| 帧行数 | 00000010 | 2 | 1 |
| 帧列数 | 00000011 | 3 | 1 |
| 按行序排列的字形 ID | 00000000 │ 00000001 │ 00000001 │ 00000001 │ 00000000 │ 00000001 | 0 │ 1 │ 1 │ 1 │ 0 │ 1 | 6 |
| 区域数量 | 00000000 00000010 | 2 | 2 |
| 区域 1:ID、单元索引 | 00000000 00001010 │ 00000000 00000000 | 10 │ 0 | 4 |
| 区域 2:ID、单元索引 | 00000000 00010100 │ 00000000 00000101 | 20 │ 5 | 4 |
得到的图像及其六个单元的索引:
图表:Rendered frame 256
图表:Cell indices, for comparison
第 24 帧(共 32 帧):应用有序的部分更新
轨迹通过有序的部分更新改变初始帧。一个单元会保留其先前的字形,直到某次更新指名该单元。
前缀字节带标识 kind 3、trace 257、负载长度 19、初始帧 256、一个附加表 400 和两个补丁步骤。左侧的标尺按字节计数。上方图像是所引用的初始帧。
中间图像中的第一补丁组和已更改单元包含三个字段:赋值计数 1、单元索引 0、字形 ID 1。将该赋值应用到初始图像:其左上单元现在显示字形 1,而其他五个单元保持原值。
底部图像中的第二补丁组和已更改单元也有一个赋值:单元 5 接收字形 0。将其应用到中间状态,而不是初始帧的新副本。结果是 1,1,1 / 1,0,0。因此两个补丁产生三幅图像,且第一个补丁的更改在第二个补丁之后依然存在。
每个赋值替换该单元的字形 ID。赋值为 0 选择空白字形;将某个单元排除在补丁之外会保留其当前值。这些更改影响此轨迹的显示状态,因此可复用的初始帧记录仍可作为起点使用。
| Meaning | Bits | Decimal | Bytes |
|---|---|---|---|
| 记录类型 | 00000011 | 3 | 1 |
| 记录 ID | 00000001 00000001 | 257 | 2 |
| 载荷字节长度 | 00000000 00000000 00000000 00010011 | 19 | 4 |
| 初始帧 ID | 00000001 00000000 | 256 | 2 |
| 附加表数量 | 00000001 | 1 | 1 |
| 附加表 ID | 00000001 10010000 | 400 | 2 |
| 补丁步数 | 00000000 00000000 00000000 00000010 | 2 | 4 |
| 补丁 1:赋值数量 | 00000000 00000001 | 1 | 2 |
| 补丁 1:单元格索引 | 00000000 00000000 | 0 | 2 |
| 补丁 1:字形 ID | 00000001 | 1 | 1 |
| 补丁 2:赋值数量 | 00000000 00000001 | 1 | 2 |
| 补丁 2:单元格索引 | 00000000 00000101 | 5 | 2 |
| 补丁 2:字形 ID | 00000000 | 0 | 1 |
第 25 帧(共 32 帧):定义一个练习页
本帧定义一个练习页,将一幅图片、一个响应及其结果连接起来。单凭显示内容无法说明接收方应当选择什么,也无法说明提交之后会发生什么。
前三个字段带标明类型 4、页码 512 及其 26 字节载荷。紧随其后的一对字段选择帧 256:显示标志 0 标识所显示的帧。页面的类型与其显示标志是彼此独立的字段。
响应字段请求一组选中的区域 ID,并提供 10 和 20 两个选项。接受字段声明一组长度为 1 的已接受集合:[10]。底部字段分别指定成功页 514、失败页 515、演示页 516,以及一条指向 516 的显式链接。字段带旁边的标尺按字节计数;列表数量与列表内容始终是彼此独立的字段。
| Meaning | Bits | Decimal | Bytes |
|---|---|---|---|
| 记录类型 | 00000100 | 4 | 1 |
| 记录 ID | 00000010 00000000 | 512 | 2 |
| 载荷字节长度 | 00000000 00000000 00000000 00011010 | 26 | 4 |
| 显示类型 | 00000000 | 0 | 1 |
| 显示 ID | 00000001 00000000 | 256 | 2 |
| 响应形态 | 00000010 | 2 | 1 |
| 选项数量 | 00000000 00000010 | 2 | 2 |
| 选项区域 ID | 00000000 00001010 │ 00000000 00010100 | 10 │ 20 | 4 |
| 已接受响应数量 | 00000000 00000001 | 1 | 2 |
| 已接受响应 1:长度 | 00000000 00000001 | 1 | 2 |
| 已接受响应 1:区域 ID | 00000000 00001010 | 10 | 2 |
| 成功页 ID | 00000010 00000010 | 514 | 2 |
| 失败页 ID | 00000010 00000011 | 515 | 2 |
| 被动页 ID | 00000010 00000100 | 516 | 2 |
| 链接数量 | 00000000 00000001 | 1 | 2 |
| 链接页 ID | 00000010 00000100 | 516 | 2 |
页面 512 使用第 23 帧所教的区域映射:区域 10 标识单元格 0,区域 20 标识单元格 5。一次选择记录的是一个区域 ID;它并不会替换该单元格中显示的字形。页面 512 将其响应视为一组互不相同的 ID,因此选择顺序不影响是否被接受。再次选择一个区域会将其从集合中移除。完整提交的集合必须与某个已存储的已接受响应相匹配:同时选择 10 和 20 会失败,尽管其中包含了已接受的选项 10。
页面也可以显示轨迹:显示标志 1 选择这种形式,而 0 选择固定帧。下方完整图中的演示页使用轨迹。响应形态与该显示选择相互独立。形态 1 保留一个选择,当选择另一个时将其替换;形态 2 保留一个集合;形态 3 追加一个有序序列,保留重复项。序列长度受该页面上所暴露选项数量的限制。
形态 0 是一个被动页:它有显示内容和链接,但没有可提交的响应。其成功、失败和被动页字段包含保留值 65,535,表示无引用。该值从不指代任何记录。相比之下,字形 0 是一条真实记录,可以被绘制出来。
第 26 帧(共 32 帧):展示两个具体的反馈结果
本帧将每个提交的选项与其所打开的反馈页和图片连接起来。它首先定义失败图片所使用的对比字形。
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教下棋
正文: 上方条带和小矩形定义了字形 2:两行、三列,位图字节 00101000。它的前六位构成 001 / 010;最后两位是填充。白色的第一列仍然是字形的一部分。
上方条带旁的四位数字给出了它们的字节宽度:1、2、4、1、1、1。宽度和值是不同的:payload 长度字段旁的 0100 表示值 3 是用四个字节写成的。左下方较长的模式是提交的区域 ID,而不是宽度标签。
提交的 ID 10 指向第 514 页和第 259 帧,其中填充了字形 1。提交的 ID 20 指向第 515 页和第 260 帧,其中填充了字形 2。每个反馈框先给出页面类型和 ID,然后是显示标志和帧 ID,最后是结果图片。
| Meaning | Bits | Decimal | Bytes |
|---|---|---|---|
| Record kind | 00000001 | 1 | 1 |
| Record ID | 00000000 00000010 | 2 | 2 |
| Payload byte length | 00000000 00000000 00000000 00000011 | 3 | 4 |
| Glyph rows | 00000010 | 2 | 1 |
| Glyph columns | 00000011 | 3 | 1 |
| Packed glyph mask | 00101000 | 40 | 1 |
第 27 帧,共 32 帧:选择、重置并提交一个答案
选择一个区域会编辑一个待定答案;提交它则会对其进行求值。这三个案例展示了其中的区别。
顶部案例使用操作 1 和参数 10 来选择区域 10。下面一行显示第 512 页保持活动。中间案例使用操作 3 和参数 0 来清除待定选择;页面再次保持为 512。
底部案例及其反馈图片使用操作 2 和参数 0 来提交这个现已为空的集合。它不是被接受的集合 [10],因此结果是第 515 页,在每个单元格中显示字形 2。这些是操作的示例,而不是额外的序列化数据包。
提交会记录待定答案,将其与页面的已接受响应进行比较,并以空选择打开存储的成功或失败页面。什么都不做就不会提交任何答案;提交空选择则会提交一个长度为零的答案。后续课程在空答案正确时会使用这一区别。
| Meaning | Bits | Decimal |
|---|---|---|
| Operation code, operand | 00000000 00000001 │ 00000000 00001010 | 1 │ 10 |
| Page before, page after | 00000010 00000000 │ 00000010 00000000 | 512 │ 512 |
| Operation code, operand | 00000000 00000011 │ 00000000 00000000 | 3 │ 0 |
| Page before, page after | 00000010 00000000 │ 00000010 00000000 | 512 │ 512 |
| Operation code, operand | 00000000 00000010 │ 00000000 00000000 | 2 │ 0 |
| Page before, page after | 00000010 00000000 │ 00000010 00000011 | 512 │ 515 |
第 28 帧,共 32 帧:跟随反馈和被动路由
存储的页面引用决定了接下来会打开什么。它们的数字顺序并不定义页面序列。
第一对将提交的区域 20 映射到失败页面 515。第二对和上方图片将区域 10 映射到成功页面 514。第三对和下方图片则有不同的作用:演示页面 516 链接到最终图片页面 518。
| Meaning | Bits | Decimal |
|---|---|---|
| Response 20 → failure page 515 | 00000000 00010100 │ 00000010 00000011 | 20 │ 515 |
| Response 10 → success page 514 | 00000000 00001010 │ 00000010 00000010 | 10 │ 514 |
| Demonstration page 516 → final page 518 | 00000010 00000100 │ 00000010 00000110 | 516 │ 518 |
页面 516 播放 trace 257,并且还链接到反馈页面 517。完成它的两个补丁不会自动跟随任一链接。页面 514、515、517 和 518 各自都链接回问题 512。
跟随返回链接会以空选择开始一次全新的尝试。重置只会清除问题页面上的待定答案;它无法从反馈页面中抹去已提交的答案。这些显式链接还能让学习者无需先正确作答就能打开演示。
图表:该微缩模型的完整页面图
| 从 | 动作 | 到 / 显示 |
|---|---|---|
| 512 | 提交 [ 10 ] | 514 / 帧 259,全部字形 1 |
| 512 | 提交 []、[ 20 ] 或 [ 10, 20 ] | 515 / 帧 260,全部字形 2 |
| 512 | 打开演示 | 516 / 轨迹 257 |
| 516 | 打开反馈 | 517 / 帧 259 |
| 516 | 打开最终图片 | 518 / 帧 258 |
| 514, 515, 517, 518 | 返回链接 | 512 / 问题 |
第 29 帧(共 32 帧):读取完整的微型章节
本帧在其校验章节内提供完整的微型文档。它让接收者测试先前的边界并共同记录示例。
前六个字节是头部字节 0 1 | 0 0 1 70:ID 1,正文长度 326。326 字节的正文以 214 57 | 0 2 | 0 15 | 2 0 | 1 1 开始,并包含全部十五条记录。最后四个字节是 255 64 93 120。总计为 6+326+4 = 336 字节,恰好填满从本地行 12 开始的四十二个八字节行。
最后一行包含四个正文字节和四个校验字节。没有部分数据行。读取者现在可以验证本章节的校验;解析每条记录还需要接下来展示的表格格式。这个已校验的章节属于条带,而不属于它下方的五文档有效载荷。
第 30 帧(共 32 帧):读取数值表格
表格值是无符号数。此处的值不像帧单元格那样选择字形。
前三个带指定种类 5、ID 400 和有效载荷长度 17。维度字段给出两行三列。最后两个带包含 0,1,2 和 3,4,5,每个值存储为 u16。因此每个值带占六个字节。
左侧的四位宽度计数每个带中的字节数。两个值带各自的宽度为 0110,即六个字节:三个值,每个两字节。它们下方的小标记定位这些字节边界。
| 含义 | 位 | 十进制 | 字节 |
|---|---|---|---|
| 记录种类 | 00000101 | 5 | 1 |
| 记录 ID | 00000001 10010000 | 400 | 2 |
| 有效载荷字节长度 | 00000000 00000000 00000000 00010001 | 17 | 4 |
| 表格行数 | 00000000 00000000 00000000 00000010 | 2 | 4 |
| 表格列数 | 00000011 | 3 | 1 |
| 表格值 0 – 2 | 00000000 00000000 │ 00000000 00000001 │ 00000000 00000010 | 0 │ 1 │ 2 | 6 |
| 表格值 3 – 5 | 00000000 00000011 │ 00000000 00000100 │ 00000000 00000101 | 3 │ 4 │ 5 | 6 |
轨迹 257 将此表格作为附加数据引用。记录读取器恢复其值,而不赋予它们特定于主题的含义。后续表格使用相同格式表示走法词、分数和字段宽度;展示的课程教授这些含义。
轨迹的引用使其附加表格可供读取者使用。其存储的补丁显式给出显示变化;播放器不会根据表格值计算这些变化。
使用引导程序读取有效载荷
最后两个引导帧展示章节如何形成流,以及完整消息的已用数据在哪里结束。连同先前的示例,条带定义了读取有效载荷所需的字节序、校验和、章节与清单布局、文档头以及五种记录类型。
第 31 帧(共 32 帧):定位连续章节及其边界
本帧将章节连续放置,并区分最后一个字节与其后的地址。接收者需要两者才能在正确边界停止。
上方各行有四列:章节 ID、起始、排他结束和长度。清单行为 0,0,28,28;文档行为 1,28,364,336。第二个章节恰好从第一个结束处开始。这些行描述放置位置,而非额外的头部字段。
0,1,2 行是计数序列;此示例仅包含章节 0 和 1。底部一对对比最后包含字节 363 与排他结束 364。通常,下一章节在六个头部字节、声明的正文长度和四个校验字节之后开始。
| 含义 | 比特 | 十进制 |
|---|---|---|
| 清单:ID、起始、结束、长度 | 00000000 00000000 │ 00000000 00000000 │ 00000000 00011100 │ 00000000 00011100 | 0 │ 0 │ 28 │ 28 |
| 文档:ID、起始、结束、长度 | 00000000 00000001 │ 00000000 00011100 │ 00000001 01101100 │ 00000001 01010000 | 1 │ 28 │ 364 │ 336 |
| 计数序列 0、1、2 | 00000000 00000000 │ 00000000 00000001 │ 00000000 00000010 | 0 │ 1 │ 2 |
第 32 帧,共 32 帧:找到已用末尾并验证零预留
这一帧将完整载荷的已用字节与填零的预留区分开。接收方必须在已用末尾停止解析,并检查剩余部分。
四个有界字段给出起始偏移 0、已用长度 506,509、容量 507,904 和预留长度 1,395。右侧的小计对这些行进行编号。
下面的示例包含两个分别有界的字段:上方三十二个零比特,下方八比特数字 00100000,读作 32。第一个字段是数据;第二个字段说明其宽度。它们各自的边界使数字中置位的比特不会混入零数据。
恢复并验证载荷
五个文档正文合计 506,181 字节。加上 268 字节的清单正文和 60 字节的节头与校验,得到 506,509 个已用字节。剩余的 1,395 字节必须为零,而不是另一个文档。
读取器从第 64 行开始,使用第 16 帧的映射来恢复所声明的字节数。对于每个节,它读取节头,检查正文是否适合剩余数据,验证校验和,并越过节头、正文和校验继续前进。节 ID 从 0 开始递增,每个必需的文档恰好出现一次。
第 0 节是完整消息的清单。其正文以两字节的文档计数 5 开始。每个文档条目指定一个 ID、正文长度、节校验和、条目计数以及有序的条目 ID。清单包含这些数字声明,而不是课程标题或课程顺序。
完整的读取必须将清单与收到的节和文档头进行匹配。它还必须验证记录长度、种类、引用和单元格索引。缺失的对象和无效的引用会导致拒绝;读取器不会猜测替代内容。成功显示一个片段不足以接受整条消息。
随附的 Python 解码器直接实现了这些规则。它测试旋转、反射和交换的比特状态,将引导部分与其定义的图形进行比较,并要求一次完全有效的读取。这是对已知格式的检查。从图形中发现该格式是接收方的另一项任务。
| 文档 / 节 ID | 节流偏移 | 正文字节 | 内容,为本指南标注 |
|---|---|---|---|
| 1 | 278 | 13,245 | 基本视觉词汇 |
| 2 | 13,533 | 93,017 | 64 局选集 |
| 3 | 106,560 | 35,296 | 棋盘、棋子和基本规则 |
| 4 | 141,866 | 195,452 | 实用规则、状态和着法打包 |
| 5 | 337,328 | 169,171 | 关系、战术和战略示例 |
缩略图属于引导条带。它演示了清单以及其下方字节流中五个完整文档所使用的格式。在恢复并验证该完整集合后,接收方可以打开一个已声明的条目。
玩家现在可以查找该条目的记录并显示它们。重建下一个示例中的画面不需要任何国际象棋知识。
从载荷比特到显示的画面
跟随文档 2,它存储了完整的对局,以及其第一个声明的条目,轨迹 324。我们将使用引导部分的规则重建其初始画面,然后使用课程将该画面解释为国际象棋。
找到文档并读取其声明的条目
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教会下棋
当全部六个区段都被恢复并校验之后,清单把文档 2 识别为正文长度为 93,017 字节。它的区段从载荷字节 13,533 开始。六字节的头部读作 0 2 | 0 1 107 89:先是文档 ID,然后是正文长度,高位字节在前。正文在六个字节之后开始,即载荷字节 13,539。文档偏移 0 指的就是这一点。
正文的前八个字节来自源第 116 行、第 1,816–1,879 列。它们在消息中是连续的一行 64 个单元;插图把它们重新分成八行,每行一个字节。前两个字节标识文档格式。接下来两个字节声明 64 个条目;再接下来的两个字节声明 151 条记录。所示的最后一对是第一个条目 ID。
| 字段 | 比特 | 读数 |
|---|---|---|
| 文档标记 | 11010110 00111001 | 214 57 |
| 条目数 | 00000000 01000000 | 64 |
| 记录数 | 00000000 10010111 | 151 |
| 第一个条目 ID | 00000001 01000100 | 1×256 + 68 = 324 |
条目 324 是一个存储的名字,不是下一个字节的位置。其余 63 个条目 ID 紧随其后。全部 64 个条目在六字节头部之后占据 128 字节,因此记录从文档字节 6 + 64×2 = 134 开始。
读取记录,然后顺着它们的名字找
在每条记录处,读取其一字节的类型、两字节的 ID 和四字节的内容长度。恰好消耗那么多内容字节,然后继续下一条记录。例如,记录 0 从字节 134 开始,声明了三个内容字节。它的七字节头部和三个内容字节在字节 144 结束,下一条记录从这里开始。读取全部 151 条记录,就建立了一张从每个 ID 到其存储内容的查找表。
| 记录 | 文档偏移 | 实际头部字节 |
|---|---|---|
| 字形 32 | 199 | 1 │ 0 32 │ 0 0 0 6 |
| 帧 256 | 355 | 2 │ 1 0 │ 0 0 0 76 |
| 轨迹 324 | 15,028 | 3 │ 1 68 │ 0 0 2 88 |
查找所声明的条目 324,找到一条轨迹,类型 3。它的前两个内容字节是 00000001 00000000,即 1×256 + 0 = 256:它的初始显示帧 ID。查找 256 找到上面的帧记录。这是顺着引用回到更早的一条记录;它不是跳到字节 256。轨迹的其余部分包含其附加表和有序更新。它的初始显示在应用任何更新之前使用这个帧。
- 所声明的条目 324 指向下面的记录 ↓
- 轨迹记录 324 前两个内容字节:00000001 00000000 命名其初始帧 ↓
- 帧记录 256 位于文档字节 355
把帧读作一张字形引用的网格
帧 256 的内容以 00001001 00001000 开始:九行八列。接下来的 9×8 = 72 个字节为每个帧单元给出一个字形 ID,沿每一行横向排列,然后逐行向下。这里是那些实际字节,以十进制 ID 显示。行标签和列标签是为便于阅读而添加的。网格之后,两个零字节给出可选区域数为 0。因此该帧的内容占据 2 + 72 + 2 = 76 字节,与其头部相符。
| 行 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
| 0 | 41 | 39 | 40 | 42 | 43 | 40 | 39 | 41 |
| 1 | 38 | 38 | 38 | 38 | 38 | 38 | 38 | 38 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 5 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 6 | 32 | 32 | 32 | 32 | 32 | 32 | 32 | 32 |
| 7 | 35 | 33 | 34 | 36 | 37 | 34 | 33 | 35 |
| 8 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
单元 48 是第 6 行、第 0 列,因为 6×8 + 0 = 48。它的字节是 00100000,即 ID 32。帧记录从字节 355 开始。在其七字节头部和两个维度字节之后,网格从 355 + 7 + 2 = 364 开始。因此单元 48 位于文档字节 364 + 48 = 412,即载荷字节 13,539 + 412 = 13,951。来自帧 16 的映射把它放在源第 118 行、第 1,016–1,023 列。该字节命名一个字形;它的八个源比特本身并不画出那个字形。
查找位图并将其放入单元
记录 32 是一个字形,类型为 1。它的六个内容字节是 5 5 | 1 8 64 0:行数、列数,然后是打包的位图。尺寸要求 5×5 = 25 个图像位。四个位图字节携带这前 25 位,随后是七个零填充位,以补全最后一个字节。每次取五个图像位,从左到右填充每个位图行,然后继续到下一行。填充补全了存储字节,但不属于图像。
接收方现在在帧单元格 48 中绘制该位图。其他每个单元格都通过在同一文档中查找自己的字形 ID 来绘制。重复的 ID 重用同一位图。记录 0 的内容为 2 2 | 0:一个 2×2 的零位位图。它在帧指定字形 0 的位置提供空白块。结果是条目 324 的完整初始图像:
图表:存储帧的全部九行。高亮单元格包含字形 32。
现在每个字形形状都来自存储的位图,每个位置都来自存储的帧单元格。接收方仅使用引导程序的规则就能绘制此图像。理解这些形状、排列和底部行的含义是恢复课程的下一个任务。稍后,我们将回到同一轨迹,并应用其第一个存储更新。
从有效载荷中学习国际象棋
刚刚恢复的图像是一个接收方在理解国际象棋之前就能绘制的显示。文档 1 提供了视觉词汇;国际象棋课程随后解释 8×8 棋盘、双方、六种棋子类型、起始位置和交替行棋。本指南使用通常的英文名称,White 和 Black;White 先行。接收方没有理由将任何特定形状与国际象棋棋子关联,因此字形可以是任意的。我选择了类似熟悉国际象棋棋子的图案。它们的角色仍需通过布局、移动和重复示例来教授。
学习路线从文档 1 的表示课程开始,然后是文档 3、4 和 5:基本规则、实用规则和历史,然后是关系和有限的战略指导。文档 2 提供了完整对局选集。
一个示例展示了输入及其结果。对比通过展示被拒绝的结果或改变条件(如阻挡子或易位权)来使区别可见。练习要求接收方使用引导程序中的页面机制在存储的选项中进行选择。一个页面可以分组多个问题:学习者分别为每个问题选择答案,并提交组合集合。播放器根据页面存储的接受响应检查整个集合。
被动路线展示解释和反馈,而不要求正确提交。两条路线使用相同的记录操作。国际象棋计算在课程编写时进行;播放器稍后呈现结果图像、选项和反馈。
字形 ID 仍然是一个局部名称。它作为兵、马或其他棋子的角色来自示例。同一字形可以出现在棋盘上,在问题中标识选中的棋子,并在移动后出现在其目标位置。
图表:兵
图表:马
图表:象
图表:车
图表:后
图表:王
识别问题及其答案
问题必须标识其主题并显示棋盘。这个马课程使用 29×10 的显示帧,包含一个 8×8 棋盘和其下方单独的 8×8 答案网格(或称掩码)。它们之间的页脚标明方、选中棋子、方格和问题类型。
这里页脚选择棋盘第 7 行、第 1 列(即添加的国际象棋坐标中的 b1)的第一方马。问题要求合法的目标格。马可以移动到 a3 和 c3。它的跳跃在几何上也到达 d2,但一个友方兵占据该格。
图表:一个源帧,两个不同的图像区域
图表:棋盘裁剪 · b1 上选中的马
图表:答案掩码裁剪 · a3 和 c3
| Source footer field | 实际值 / 字形 | 本课中的含义 |
|---|---|---|
| 行棋方 / 选中棋子 | 3 / 33 | 先行方 / 马 |
| 行 / 列 | 19 / 13 | 数字 7 / 1 的字形 |
| 问题模式 | 9 | 合法落点 |
| 正标记 | 6 | 所携带的答案被确认为真 |
Document 3,trace 3068,step 33。在这个 29×10 的显示帧内,棋盘占据第 1–8 行、第 1–8 列;掩码占据第 11–18 行、第 1–8 列;页脚位于第 9 行。坐标从 0 开始。掩码中加号形状的字形 5 标记了 8×8 掩码内的索引 40 和 42,对应 a3 和 c3。此图展示的是已存储的答案。
普通吃子会移除目标格上的对方棋子,并把移动的棋子放到该格。己方棋子会阻止移动到该格。合法走法还必须让自己的王保持安全。对王的攻击称为将军;被将军且无合法逃脱手段即为将死。棋局结束时,王仍留在棋盘上。
王的安全取决于走子后的局面。在一个课程示例中,e1 上的王试图吃掉 d1 上的象,而对方车位于 f1。走子之前,王本身挡住了车通往 d1 的线路。一旦王离开 e1,该线路就会打开,因此这次吃子不合法。课程展示了该尝试走法所导致的占位与攻击情况。测试王吃子意味着移动王、移除被吃的棋子,并在改变后的局面中检查其目标格。
受控格与合法走法
控制关系遵循棋子在当前显示局面下的移动几何。对于车、象或后,控制沿每条允许的直线延伸到第一个被占据的格子,包括它所保护的己方棋子。牵制不会移除受控格。这里 b5 上的象沿一条对角线穿过 c6 上的马,指向马方的王所在的 e8。移动该马会暴露王。该马仍然控制八个格子,但没有任何合法落点。
控制问题遵循马的跳跃模式。合法走法问题还会检查走子是否会暴露自己的王。课程用不同的模式字形区分这些问题。棋盘保持不变;空的合法走法掩码与八格控制掩码是对不同问题的回答。这匹马不能沿牵制它的对角线移动。被牵制的滑动棋子或兵有时可以沿其被牵制的线路移动,同时继续掩护自己的王,因此牵制并不总是意味着棋子没有合法走法。
图表:One board, two questions
图表:Selected black knight c6; bishop b5; king e8
图表:Control mask · eight controlled squares
图表:Legal mask · no legal destination
控制掩码:document 3,trace 3124,step 1。合法走法掩码:trace 3119,step 8。二者展示相同的棋盘和选中的马。
学习走法如何被打包
数值表提供值,但其含义也必须被教授。Document 4 解释了走法的起始格、目标格和升变选择如何构成一个打包数字。这些课程是负载的一部分,并通过 bootstrap 所建立的阅读器变为可访问。
一个存储的示例使用起始格 52、目标格 36 和选择 0:e2→e4,无升变。格子按行编号,从 a8=0 到 h8=7,向下延续到 a1=56。选择 0 表示无升变;1、2、3、4 分别选择后、车、象、马。
前后两个棋盘已经出现在源显示中。下面的两张裁剪图展示了该显示在某个 trace 步骤填入打包结果之前和之后的数值部分。棋盘图片在这两个状态之间没有移动。
图表:A stored lesson combines the three move fields
图表:Given: 52 , 36 , 0 ; packed-word row blank
图表:Shown result: packed word 26912
| 这些裁剪图中的行 | 其代表的内容 |
|---|---|
| 顶部 | 十进制起始格 52、目标格 36、选择 0 |
| 中部 | 各自的 6、6、3 位:110100 / 100100 / 000 |
| 底部 | 完整的 16 位字:0 / 110100 / 100100 / 000 |
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教人下棋
正文: 文档 4,第 1076 页→trace 1075。裁剪图显示的是显示帧的第 9–11 行和第 0–18 列。位 0 使用字形 2,十进制数字 0 使用字形 22,空白单元格使用字形 0。它们是三条不同的记录。
完整的字是 0110100100100000 = 26,912,计算方式为 52×512 + 36×8 + 0。它的字段是一个前导零、六个起点位、六个终点位和三个选择位。其他已存储的示例会把一个字拆解成这些字段,并拒绝前导 1 或超出 0–4 的选择。
表格 [16,1,6,6,3] 描述的就是这些宽度:总共 16 位,字段分别为 1、6、6 和 3 位。图片教的是哪些字段表示填充、起点、终点和选择。仅凭表格只能得到宽度,得不到这种解释。现在我们可以用同一条规则来理解选集中的一步棋。
一个格式正确的走法字不一定是一步合法的棋。打包会检查字段范围;解包还会拒绝非零的前导位。这两种操作都不检查棋盘、轮到谁走,或者是否可能升变。这些问题需要棋规和局面状态。
跟随一步棋从源到显示
选集里的第一局棋有 52 个单步,或称 ply,以 d2→d4 开始。上面的字节到图片的走查恢复了这局棋的初始帧。现在跟随它的第一步,就能把存储数字的含义与单独存储的显示更新联系起来。选集以两种形式存储这步棋:一个数值走法字和一个显示补丁。接收方必须分别恢复它们,并理解为什么它们描述的是同一步棋。
1. 生成走法字和显示补丁
棋局准备从 PGN 格式的选集开始,PGN 是一种人类可读的棋局记录记法。源导入器通过从标准初始局面合法重放来检查每局棋的主线。它记录每个中间棋盘、轮到哪一方走,以及每步棋的起点、终点和显式升变选择。这里的第一步给出 [51,35,0]。打包得到 51×512 + 35×8 = 26,392,存储为字节 103 24。
同一次重放还提供走棋之前和之后的棋盘。比较它们的显示单元格会产生三项赋值:在单元格 35 放置兵字形 32,将单元格 51 清为字形 0,并将页脚单元格 64 从侧方字形 3 改为侧方字形 4。走法字和补丁来自这次共同的重放。读者不需要从一个推算出另一个。
消息构建器加载已检查的棋局和呈现数据,打包走法表,并组装文档。它会在使用保留的输入之前先验证它们。这一构建使用合格的呈现数据,而不是在每次构建时重新导入 PGN。
创作代码在棋局之间共享相同的字形、帧和表格,然后分配 trace ID。在文档 2 中,trace 324 引用初始帧 256、走法表 257 和得分表 258。打包还会把模式表 388 作为另一个引用加入。这些 ID 只在本文档内标识对象。
| 文档 2 中的记录 | 类型 | 它为 trace 324 提供什么 |
|---|---|---|
| 256 | 2 : 帧 | 9×8 初始图片:64 个棋盘单元格 + 8 个页脚单元格 |
| 257 | 5 : 表 | 52 行 × 1 列的打包走法字 |
| 258 | 5 : 表 | 1 × 1 得分表,值 1 |
| 388 | 5 : 表 | 1 × 5 模式:16, 1, 6, 6, 3 |
| 324 | 3 : trace | 初始 256,data[ 257,258,388 ],52 个字面补丁 |
2. 将文档存储在带校验的扇区中
文档 2 包含 93,017 字节。它的六字节扇区头是 0 2 | 0 1 107 89:扇区 ID 2,正文长度 93,017。对该头和正文计算 CRC-32C 得到 182 147 233 40。加上四个校验字节后,得到一个 93,027 字节的扇区。
该扇区从流字节 13,533 开始,映射到物理行 116、列 1,768。它的正文从六字节后开始,即流字节 13,539。边界落在一个物理行内部:扇区存储沿字节流连续排列,没有行包或行分隔符。
3. 恢复并验证文档 2
文章标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教会下棋
正文: 接收方通过阅读清单部分和文档 1 的各段长度来找到这个边界。清单声明了文档 ID 2、正文长度 93,017、预期校验值 182 147 233 40,以及 64 个条目 ID,从 324 开始。这些声明必须与收到的段和文档头相符。
文档头以 214 57 | 0 64 | 0 151 开头:标记、64 个条目和 151 条记录。它的第一个条目是 1 68,即 324。逐条读取每个以长度分隔的记录,就建立了一张从 ID 到记录的映射。解析 trace 324 后找到帧 256 以及表 257、258 和 388。Schema 388 位于文档接近末尾处,因此即使目标记录出现在后面,引用也必须能正常工作。
图表:走法表 257 与 trace 324:实际记录字节
| 实际字节值(十进制) | 解读 |
|---|---|
| 5 │ 1 1 │ 0 0 0 109 | 类型 5,ID 257,载荷 109 字节 |
| 0 0 0 52 │ 1 | 52 个表行,1 列 |
| 103 24 | 第一个 u16 值:26,392 |
| 3 │ 1 68 │ 0 0 2 88 | 类型 3,ID 324,载荷 600 字节 |
| 1 0 │ 3 │ 1 1 │ 1 2 │ 1 132 │ 0 0 0 52 | 初始 256;3 个引用 257、258、388;52 个补丁 |
这些转录中的空格只是为了便于阅读而分隔字段;它们并非存储的分隔符。该表的载荷长度 109 字节和它的行数 52 是不同的字段。
4. 定位并读取第一个走法字
表 257 从文档字节 438 开始。其七字节记录头之后是一个四字节行数和一个一字节列数。因此它的第一个值从字节 450 开始,占据字节 450–451。
文档正文从流字节 13,539 开始。加上 450 就把第一个值定位到流字节 13,989–13,990。帧 16 的映射把它的十六个位放在物理行 118、列 1,320–1,335。它们读作 0110011100011000:字节 103 和 24,得到 103×256+24 = 26,392。
图表:第一个走法字,直接来自工件
从左到右读取这十六个位置:0110011100011000。表中在显示这些位的读数的同时保持同样的位可见。
| 表示形式 | 相同的承载值 |
|---|---|
| 两个字节,十进制 | 103 / 24 |
| 一个 u16 | 103×256 + 24 = 26,392 |
| 字段,二进制 | 0 │ 110011 │ 100011 │ 000 |
| 字段,十进制 | 填充 0 │起点 51 │目标 35 │选择 0 |
5. 解读走法字段
按照文档 4 中讲授的含义应用 schema 388:0 | 110011 | 100011 | 000。这些字段给出填充 0、起点 51、目标 35 和选择 0:d2→d4,无升变。这些格子编号在 8×8 棋盘上使用行优先顺序;它们与物理消息中的坐标不同。
表读取器恢复出值 26,392。要把它解读为一步棋,需要课程对各字段的说明。原生播放器不使用这个字来计算合法的棋盘更新;它显示的是单独存储的补丁。
6. 应用存储的补丁
Trace 324 的第一个补丁占据文档字节 15,048–15,058:0 3 | 0 35 32 | 0 51 0 | 0 64 4。计数为三,随后是赋值(格子 35,字形 32)、(格子 51,字形 0)和(格子 64,字形 4)。其中两个改变棋盘格子;第三个改变页脚的轮到哪一方标记。
无论补丁之前还是之后,字形 32 都指向先前恢复出的同一张位图:一张 5×5 的图片,掩码字节为 1 8 64 0。补丁改变的是它被绘制的位置。字形记录本身保持不变。
记录 32 → 一张 5×5 位图
00000 / 00100 / 00100 / 00100 / 00000
字节 1、8、64、0 的前 25 个位,先逐行再向下。
图表:第一个补丁改变两个棋盘格子
图表:补丁之前 · 帧 256,棋盘区域
图表:补丁 1 之后 · d2 为空,兵在 d4
| 格子索引 | 之前字形 ID | 赋值 | 结果 |
|---|---|---|---|
| 35(d4) | 0 | 32 | 绘制兵位图 |
| 51(d2) | 32 | 0 | 绘制空白位图 |
| 64(页脚,第一个格子) | 3 | 4 | 轮到第二方走棋 |
帧为 9×8;这些图片裁剪了它的前八行。格子 64 在棋盘之外,在下面的完整回放中单独显示。着色区域标识被赋值的棋盘格子。
两种存储表示是一致的:走子字指定了 d2→d4,而补丁在这些格子之间移动兵,同时改变轮到哪一方的标记。在消息创建过程中,程序会将重建出的画面与从原始棋局走法得到的棋盘局面进行比对。学会了含义的接收者可以进行比较;而棋手本身只查找字形并给格子赋值。
因此,走子字、补丁和位图在一个显示出来的变化中汇合。引导程序提供了恢复并绘制它所需的操作;课程提供了它的国际象棋含义。下面的特殊走法使用相同的操作,并由额外规则决定哪些变化是有效的。
为什么棋盘局面需要历史
第一步改变两个棋盘格和一个页脚。其他走法依赖更多信息或改变更多格子。课程通过展示一个局面、一次尝试的走法及其结果,然后比较相关条件改变时会发生什么,来教授这些情形。
在下面的示例中,前后棋盘占据同一个存储显示帧的两个区域,分别位于显示帧第 0–7 列和第 9–16 列。它们不是单独的帧记录。裁剪图只显示解释每条规则所需的格子。
王车易位移动两个棋子
在这个王翼易位示例中,王和车离开 e1 和 h1,到达 g1 和 f1。四个棋盘格发生变化。易位要求相应的权利仍然存在,并且王与车之间的每个格子都为空。王必须在其起始格、离开起始格后的经过格,以及两个棋子移动后的目的地都安全。课程将可接受的易位与未满足这些条件的尝试进行比较。
一个移动后又返回的王或车不会恢复其失去的权利。对于后翼易位,车旁边的格子也必须为空,尽管王从不经过它。对该格子或车本身的攻击不会阻止易位;安全测试关注的是王的路线。
图表:之前:e1 王 / f1 空 / g1 空 / h1 车
图表:之后:e1 空 / f1 车 / g1 王 / h1 空
吃过路兵取决于紧邻的前一步
在对方兵从 d7 前进到 d5 之后,e5 上的兵可以立即在 d6 吃子。该目的地原本为空。被吃的兵从 d5 移除,因此三个格子发生变化。裁剪图显示 d5 和 e5 上方的 d6 和 e6。
一个配对示例将双方的马移开再移回,恢复相同的棋盘占用。吃过路兵的机会已经过期,因此同样的尝试吃子被拒绝,棋盘保持不变。仅凭棋子本身无法记录对方兵何时前进。
吃过路兵还必须让走子方的王保持安全。将两个兵从它们原来的格子移走可能打开一条攻击线。课程包含一个因此原因被拒绝的立即吃子,即使它的时机和兵的位置几何在其他方面都正确。
图表:之前:d5 对方兵;e5 吃子兵
图表:之后:兵在 d6;d5 和 e5 为空
升变需要单独选择
这里兵离开 b7,吃掉 a8 上的车,并被所选的升变棋子替换。选择 1 产生后;选择 4 产生马。两次走法具有相同的起点和终点,因此升变选择需要自己的字段。课程还展示了车升变和象升变,并拒绝缺失升变选择的情况。
图表:之前:车 a8;兵 b7
图表:选择 1:后 a8;b7 空
图表:选择 4:马 a8;b7 空
历史是状态的一部分
王可以离开其起始格再返回,恢复棋盘和轮到哪一方走子,同时失去易位权利。Document 4,trace 1000 的第 3 步,比较了两个匹配棋盘但历史不同:在一种情况下,第一方拥有两项易位权利;在另一种情况下,两项都没有。
标题:一条 512 KiB 的二进制消息,在没有共同语言的情况下教授国际象棋
正文: 重复局面使用的是“同一局面”的精确含义:棋子占据相同的格点,轮到同一方走棋,易位权利一致,并且任何合法的吃过路兵机会一致。吃过路兵目标格只有在实际存在合法吃子时才被计入。没有任何兵能够使用的目标格,或者会使己方王暴露的目标格,不能区分局面。
在整个合法历史中统计当前局面出现的次数,包括初始出现。它们不必连续。一个单独的计数器记录自上次兵移动或吃子以来的半回合数;两者中任一都会将其重置为零。该计数器影响和棋声明,但不属于用于比较重复局面的局面的一部分。
课程为这些区分携带合法历史与状态显示。被复用的历史片段带有显式链接和完整的起始图景,因此打开一个片段不需要玩家自行计算其起始局面。文集的 72 个显示单元格服务于一个较小的目的:其棋盘和页脚显示走棋与结果,而不列出所有易位权利或吃过路兵格。
对局何时结束
没有合法走法的一方,如果其王被将军,则被将死;否则为逼和。将死是负;逼和是和。Golden Board 还识别出三类任何一方都无法将死对方的情形:王对王、王和象对王、王和马对王。其规则机制在一步合法走法到达这些棋盘结局之一后结束对局,并拒绝后续的走法或声明。
一旦当前局面至少出现三次,即可提出三次重复的声明。五十回合声明需要自上次兵移动或吃子以来至少 100 个半回合。两种条件都不会自动结束对局:轮到走棋的一方必须明确声明符合条件的和棋。一步会达到阈值的走法不会提前使该声明可用。课程显示符合条件的声明,以及接受或拒绝它们的单独事件。
对局进行中任一方都可以认输,判对方获胜。和棋协议需要双方各自走完一步后明确同意。这些声明有已知的原因。文集比分只记录结果:在非终局棋盘上的胜或和,并不区分认输、协议和声明。
这是项目实用的国际象棋配置。它排除了自动的五次重复和 75 回合裁决、预定下一回合的声明程序、比赛程序,以及针对不可能将死的局面的通用求解器。三类已识别的死局类别之外的子力不会获得通用的死局判定。
战术、将杀与战略指导
后续课程在控制与合法性之上教授攻击、防守、牵制和击双。这里的击双是指一个棋子几何上攻击至少两个对方棋子。仅凭这一事实并不能证明任一吃子合法或有利。通路兵在其所在直线或相邻直线上前方没有对方兵;它仍然面对王、其他棋子和走棋时序。
将杀教学包括王后和王车续着,并带有以逼和告终的对比。一条以将杀告终的合法线路仍可能取决于对手选择失败的应着。为了支持强制获胜,获胜方可以选择其续着,但每一步合法防守走法和每一个符合条件的防守方和棋声明都必须被覆盖。所有产生的分支都必须以所断言的胜利告终。
该消息携带这一区分的有限实例。其中一个以白方王在 f3、后在 h4,黑方孤王在 g1 开始。白方将后走到 g3。黑方仅有的合法走法是王 g1→f1 和王 g1→h1。存储的续着以 g3→f2 的后应对第一种,以 g3→g2 的后应对第二种;两者都将死。只覆盖一种应着会使强制获胜的断言不完整。玩家呈现这些存储的显示和表格,而无需搜索将杀线路。
战略课程使用可观察的事实,例如子力出动、中心控制、开放线和机动性。其粗略的子力价值尺度为:兵记 1,马或象记 3,车记 5,后记 9;王没有兑换价值。这些计数和比较提供的是指导,而非对更优局面或最佳着法的判定。一个完整的走子检查流程首先确定对局是否处于活动状态、轮到哪一方走棋、王是否被将军,以及有哪些可用的和棋主张。随后它检查合法的选择以及所示着法的效果,包括吃子、将军和对局结束。比较仅限于实际给出的后续着法。
回放一局完整对局
这局 52 个半回合的对局共有 53 个显示状态:其初始帧以及每次补丁后的结果。要重建某个状态,复制初始帧并应用截至该点的所有补丁。向前回溯以同样的方式重建较早的状态;它不需要反转棋步。
棋盘和八格页脚分别显示在下方。页脚第 0 格标识轮到哪一方走棋。在最后一个补丁中,页脚第 1 格变为字形 11,即第二方结果标记。记分表 258 包含 1,记录第二方获胜。这一存储的结果并不意味着最终显示的棋盘是将死。
图表:对局 1:全部 53 个显示状态与页脚
使用 Next move 应用下一个存储的补丁,使用 Previous 重建前一个状态,使用 Reset 恢复起始状态。这 53 个状态覆盖 0–52 个半回合。蓝色区域标记被清除的格子;赭色区域标记被分配的棋子;青色区域标记页脚的变化。解读出的走子字单独列出。
图表:对局 1 棋盘 · 初始局面
第一方走棋;结果标记为空白。
第 1 个状态,共 53 个 · 尚未走子
初始帧 256
走子字详情从第一个存储的更新开始。
未应用补丁。源图片有 64 个棋盘格和 8 个页脚格。
这些控件检查存储的着法和补丁。本页面不计算国际象棋规则,也不生成合法着法。
图表:第 1 个半回合后 · d2→d4
图表:第 19 个半回合后 · 第一方易位
图表:第 52 个半回合后 · 最终携带的棋盘
这三个检查点展示选定的状态,无需交互。在 64 局对局中,该制品存储了 6,890 个半回合和 6,954 个初始或更新后的棋盘状态。对局记录不含姓名、日期、开局标签或评注。
播放器通过应用其存储的格子变化来显示易位、升变和吃过路兵。解读走子字或判定新着法是否合法,需要课程所教的规则。该图片播放器两者都不做。
在你离开之前
从一方格比特走到一盘对局需要耐心。感谢你付出如此多的时间和注意力。
如果有任何不清楚、似乎有误或可以解释得更好的地方,请告诉我。欢迎提出问题、更正和其他想法,无论它们涉及 Golden Board 本身还是本指南。
也欢迎你在源代码基础上进行构建。尝试另一个主题、另一种教学方式,或一个不同的实验。
如果你分享或改编该项目,或在研究中使用它,请注明出处并链接到原始作品;仓库中包含 BibTeX 引用。
我很想看看你能用它做出什么。