一、实验目的
- 分析和理解指定的需解决问题。
- 利用LC-3的汇编代码设计实现相关程序。
- 通过LC-3仿真器调试和运行相关程序并得到正确的结果。
二、实验内容
四子棋是一款普遍流行的简易型桌面游戏，据说，虎克船长曾因专注于此游戏而长期隐身在住所，当船员们发现船长的这一专长之后，他们称这个游戏为“船长的情妇”。
四子棋是个双人游戏，两人轮流下棋，棋盘由行和列组成的网格，每个选手每次下一个子直到两人中有一人的棋子连成一条水平线、垂直线或者是对角线。
本实验需要在LC-3中实现简易版四子棋的游戏，两位选手通过键盘和输出窗口轮流交互操作，棋盘由6 X 6的网格组成。
游戏规则如下：
- 两位选手依次轮流落子；
- 选手不能悔棋；
- 有子的地方不能继续落子；
- 直到有一方的四个棋子能够连成一条水平线、垂直线或者是对角线；
- 如果棋盘已满，无人获胜，则平局。
游戏最初时应该打印空的棋盘，可以用ASCII码"-" （即ASCII 码 x002D）来表示该处为空，“O”(ASCII 码 x004F)表示第一位选手的棋子，“X” (ASCII 码 x0058)来表示第二位选手的棋子，为了让棋盘更易于观察，在各列间加一个空格，第6列之后不要添加，初始棋盘应该如下：
- - - - - -
- - - - - -
- - - - - -
- - - - - -
- - - - - -
- - - - - -
选手一始终先下第一步棋，然后两者轮流落子，在每次落子之后，应该打印该选手的信息，提示他落子，以选手一为例，应该打印信息如下：
Player 1, choose a column:
为了明确选手的落子的位置，该选手应该输入数字1-6，然后回车，数字1-6指示在落子所在的列，从左到右，无需输入行号，程序应默认从行号6到行号1递减的顺序填入该棋子，若前后输入的列号相同，则行号减一。例如，如果选手第一次在左起第二列落子，应该输入2，然后回车，则该棋子落在行6列2处，当后面输入的列号再次为2时，则将棋子落子行5列2处，以此类推，详情见后续示例输出。程序应该确保选手输入的数字对应正确的列的范围，如果输入不合理，应该输出一条错误信息，提示该选手继续输入，例如，如果对于选手一：
Player 1, choose a column: D
Invalid move. Try again.
Player 1, choose a column: 7
Invalid move. Try again.
Player 1, choose a column:
程序应该一直提示该选手，知道输入正确的数字，当用户输入完成，程序应通过显示回馈给选手，然后通过换行符(ASCII 码 x000A)换行。
当选手输入成功后，程序应打印更新后的棋盘，并检查是否有人获胜，如果没人获胜，则轮到下一位输入。
当其中一位获胜或平局时，游戏结束，程序显示最后的棋盘情况并终止（Halt）。例如，如果选手二有四子相连，应该输出：
Player 2 Wins.
如果平局，程序应该输出：
Tie Game.
三、实验步骤与结果
整体流程（main函数）
我尝试性设计的实验的整体流程如下图所示。该流程图即代码中main函数的工作。
棋盘矩阵和回合方的表示
用一个6×6的二维矩阵表示棋盘，棋盘上没有落子的位置用0表示，Player 1落子的位置用1表示，Play 2落子的位置用-1表示。矩阵的下标从0开始。
计算机中的内存地址是连续的，因此需要连续分配一维的36个单元的内存空间。具体操作如下：
;
;矩阵建立及其初始化
;
ARRAY .BLKW #36
在二维矩阵上的坐标和在一维上的坐标有一一对应关系。例如在二维坐标 (i , j )对应内存上从矩阵入口处开始数的第(6 × i + j)个位置上。而在矩阵内存上的第index个位置，则对应着二维矩阵坐标(index // 6, index % 6)。其中“//”表示整除，“%”表示取余数。
因为在本实验中会频繁将坐标进行一维和二维的转换，我实现了multi函数和div函数。multi函数的功能是将传入参数乘以6返回，div函数的功能是返回传入参数的商和余数。
用一个寄存器R0储存当前落子方。当寄存器存储着1时，当前回合由Player 1落子；存储着-1时，由Player 2落子。
下文详细论述主流程图中的各个模块的具体实现方法，并且附上流程图。
实现print函数：打印当前局面
要实现打印函数，只需要对矩阵内存上的值依次遍历即可。如果矩阵中元素的值是0，输出“-”；如果是1，输出“O”；如果是-1，输出“X”。需要注意的是，每一次输出“-”都要进行判断，正常情况下输出空格，但是需要换行的时候，就直接换行。流程图如下：
实现isTie函数：判断当前局面是否平局
值得注意的是，如果平局，那么一定是棋盘矩阵中的第0行的6个元素全部不为0。也就对应着内存上自ARRAY到ARRAY + 5的6个位置。因此只需要判断这6个位置是否全部不为0即可。如果全不为0，则该局面为平局；如果存在非0，则该局面不为平局。其流程如下：
实现Play函数：玩家输入坐标返回实际落子位置
玩家输入的坐标是一个纵坐标，该函数要找到这一列的合法落子位置，并返回其实际坐标（一维的）。如果这个坐标不存在（该列已满或者输入非法），则输出错误提示并返回-1。
根据当前回合方的不同，这个函数分为Play1和Play2两种。其功能是相同的。
算法思想：假设输入纵坐标是j（从0开始）最后一行的入口地址是ARRAY + 30 + j。那么从此地址开始，不断减6（即退一行），寻找值为0的位置，找到了则返回该下标；如果一直找不到，则返回-1。
流程图如下：
实现isOver函数：判断某一方是否胜利
该函数有两个参数：落子坐标index和落子值value。其含义是，当某一方将ARRAY[index]的数值修改为value以后，该游戏是否可以区分出胜负？
该函数是本实验的核心，需要进行四种判断：横向判断、纵向判断、主对角线方向判断和副对角线方向判断。
实现上述四种情况的四子成线的判断，不考虑暴力算法，因为效率低下，且多重循环的设计也较为困难，容易出现混乱。因此我采用下述优化后的算法。
每当一个棋子落子以后，势必会改变局面，可能会出现新的四子成线的情况。这种情况可能没有，但是如果有的话，这个新的落子一定会成为成线四子中的一员。那么我们以这一个新落的棋子为中心，向下图所示的七个方向进行扩展：
例如，要判断横方向是否四子成线，需要统计落子点的左侧相邻的与己方连续相同棋子的个数。如下图所示，红色圆形棋子为新落子，那么在做横方向判断的时候，可以以该棋子为中心，向左和向右延伸。在其左侧有两个连续相同的棋子，其右侧有一个连续相同的棋子，加上自身，刚好四子成线，因此判断圆方胜利。
而纵方向、主对角线方向、副对角线方向的判断，都与此相似。这样设计出来的算法，效率更高，并且在编码实现的过程中，也更为简洁。
以上是该实验实现的思想。下一节将从多个角度测试本程序的正确性和健壮性。
测试1：横方向胜利
测试2：纵方向胜利
测试3：主对角线方向胜利
测试4：副对角线方向胜利
测试5：平局
测试6：非法输入
左图中测试了顶部溢出的非法输入，右图中测试了非法字符的错误输入。对这两种错误输入，程序都弹出了错误提示，并且提醒玩家重新输入。说明该程序健壮性良好。
四、完整代码
以下是完整的四子棋LC-3代码。
;
; author: Cao-Yixuan 2019282129
; date:2021.6.8
; function: a game called Connect Four
;
;
.ORIG x3000
;
JSR main
;
;函数：打印矩阵
;
print ST R0 SAVE_R0 ;被调用者保存
ST R1 SAVE_R1
ST R2 SAVE_R2
ST R3 SAVE_R3
ST R4 SAVE_R4
ST R5 SAVE_R5
ST R6 SAVE_R6
ST R7 SAVE_R7
;
;R1 = 36，控制循环
;R2 = 6，控制换行
;R3 = ARRAY
;
LEA R3 ARRAY
AND R1 R1 #0
ADD R2 R1 #6
ADD R1 R1 #15
ADD R1 R1 #15
ADD R1 R1 R2
;
PRINT_LOOP LDR R0 R3 #0
BRp PRINT_1_CH
BRn PRINT_2_CH
LD R0 BLANK
BRnzp PRINT_CH
PRINT_1_CH LD R0 P_1_CH
BRnzp PRINT_CH
PRINT_2_CH LD R0 P_2_CH
BRnzp PRINT_CH
PRINT_CH TRAP x21
ADD R3 R3 #1
ADD R2 R2 #-1
BRp PRINT_BLANK
ADD R2 R2 #6
LD R0 ENDLINE
TRAP x21
BRnzp PRINT_L_END
PRINT_BLANK LD R0 BLANK1
TRAP x21
PRINT_L_END ADD R1 R1 #-1
BRp PRINT_LOOP
;
;
;
LD R0 SAVE_R0 ; 被调用者恢复
LD R1 SAVE_R1
LD R2 SAVE_R2
LD R3 SAVE_R3
LD R4 SAVE_R4
LD R5 SAVE_R5
LD R6 SAVE_R6
LD R7 SAVE_R7
RET
;
P_1_CH .FILL x004F
P_2_CH .FILL x0058
ENDLINE .FILL x0D
BLANK .FILL x002D
BLANK1 .FILL x20
;
;函数：PLAY1落子
;输入:TEMP0
;输出:TEMP0
;如果落子失败，R6处返回-1
;如果落子成功，R6处返回落子位置的下标
;
play1 ST R0 SAVE_R0 ;被调用者保存
ST R1 SAVE_R1
ST R2 SAVE_R2
ST R3 SAVE_R3
ST R4 SAVE_R4
ST R5 SAVE_R5
ST R6 SAVE_R6
ST R7 SAVE_R7
;
;初始化返回值R6 = -1
;
AND R6 R6 #0
ADD R6 R6 #-1
;
;边界检查
;
LD R0 TEMP0 ;传入参数j
ADD R1 R0 #-6
BRzp P_1_ERROR
ADD R1 R0 #0
BRn P_1_ERROR
;
;循环
;R2 = ARRAY+30+j,入口
;R3 = ARRAY+j,出口
;
LEA R2 ARRAY
ADD R3 R2 R0
ADD R2 R3 #15
ADD R2 R2 #15
NOT R0 R3
ADD R0 R0 #1
P_1_LOOP LDR R3 R2 #0
ADD R3 R3 #0
BRz P_1_RIGHT
ADD R2 R2 #-6
ADD R4 R2 R0
BRzp P_1_LOOP
P_1_ERROR LEA R0 ERROR
TRAP x22
BRnzp PLAY_1_END
P_1_RIGHT AND R6 R2 R2
AND R4 R4 #0
ADD R4 R4 #1
STR R4 R6 #0
LEA R7 ARRAY
NOT R7 R7
ADD R7 R7 #1
ADD R6 R6 R7
BRnzp PLAY_1_END
PLAY_1_END ST R6 TEMP0 ; 输出
LD R0 SAVE_R0 ; 被调用者恢复
LD R1 SAVE_R1
LD R2 SAVE_R2
LD R3 SAVE_R3
LD R4 SAVE_R4
LD R5 SAVE_R5
LD R6 SAVE_R6
LD R7 SAVE_R7
RET
;
;函数：PLAY2落子
;输入:TEMP0
;输出:TEMP0
;如果落子失败，R6处返回-1
;如果落子成功，R6处返回落子位置的下标
;
play2 ST R0 SAVE_R0 ;被调用者保存
ST R1 SAVE_R1
ST R2 SAVE_R2
ST R3 SAVE_R3
ST R4 SAVE_R4
ST R5 SAVE_R5
ST R6 SAVE_R6
ST R7 SAVE_R7
;
;初始化返回值R6 = -1
;
AND R6 R6 #0
ADD R6 R6 #-1
;
;边界检查
;
LD R0 TEMP0 ;传入参数j
ADD R1 R0 #-6
BRzp P_2_ERROR
ADD R1 R0 #0
BRn P_2_ERROR
;
;循环
;R2 = ARRAY + 30 + j, 作为入口
;R3 = ARRAY + j, 作为出口
;
LEA R2 ARRAY
ADD R3 R2 R0
ADD R2 R3 #15
ADD R2 R2 #15
NOT R0 R3
ADD R0 R0 #1
P_2_LOOP LDR R3 R2 #0
ADD R3 R3 #0
BRz P_2_RIGHT
ADD R2 R2 #-6
ADD R4 R2 R0
BRzp P_2_LOOP
P_2_ERROR LEA R0 ERROR
TRAP x22
BRnzp PLAY_2_END
P_2_RIGHT AND R6 R2 R2
AND R4 R4 #0
ADD R4 R4 #-1
STR R4 R6 #0
LEA R7 ARRAY
NOT R7 R7
ADD R7 R7 #1
ADD R6 R6 R7
BRnzp PLAY_2_END
PLAY_2_END ST R6 TEMP0 ; 输出
LD R0 SAVE_R0 ; 被调用者恢复
LD R1 SAVE_R1
LD R2 SAVE_R2
LD R3 SAVE_R3
LD R4 SAVE_R4
LD R5 SAVE_R5
LD R6 SAVE_R6
LD R7 SAVE_R7
RET
ERROR .STRINGZ "Invalid move. Try again.\n"
;
;函数：判断是否是平局
;output:TEMP1
;
isTie ST R0 SAVE_R0 ;被调用者保存
ST R1 SAVE_R1
ST R2 SAVE_R2
ST R3 SAVE_R3
ST R4 SAVE_R4
ST R5 SAVE_R5
ST R6 SAVE_R6
ST R7 SAVE_R7
LEA R0 ARRAY
AND R1 R1 #0 ;index = 5 to 0
ADD R1 R1 #5
AND R2 R2 #0 ;返回0
;
TIE_LOOP ADD R4 R0 R1
LDR R3 R4 #0
ADD R3 R3 #0
BRz TIE_RET
ADD R1 R1 #-1
BRzp TIE_LOOP
ADD R2 R2 #1 ;返回1
TIE_RET ST R2 TEMP1
LD R0 SAVE_R0 ; 被调用者恢复
LD R1 SAVE_R1
LD R2 SAVE_R2
LD R3 SAVE_R3
LD R4 SAVE_R4
LD R5 SAVE_R5
LD R6 SAVE_R6
LD R7 SAVE_R7
RET
;
;矩阵建立及其初始化
;
ARRAY .BLKW #36
;
;保存寄存器
;
SAVE_R0 .FILL #0
SAVE_R1 .FILL #0
SAVE_R2 .FILL #0
SAVE_R3 .FILL #0
SAVE_R4 .FILL #0
SAVE_R5 .FILL #0
SAVE_R6 .FILL #0
SAVE_R7 .FILL #0
;
;临时存储用寄存器
;
TEMP0 .FILL #0
TEMP1 .FILL #0
TEMP2 .FILL #0
TEMP3 .FILL #0
TEMP4 .FILL #0
TEMP5 .FILL #0
TEMP6 .FILL #0
TEMP7 .FILL #0
TEMP8 .FILL #0
TEMP9 .FILL #0
;
;The key function: is it over?
;if return 1, play1 wins
;if return -1, play2 wins
;if return 0, it is not over
;INPUT1: TEMP0, an index of the array
;INPUT2: TEMP1, the value of array[TEMP0]
;OUTPUT: TEMP0, a bool value
;
isOver ST R0 SAVE_R0 ;被调用者保存
ST R1 SAVE_R1
ST R2 SAVE_R2
ST R3 SAVE_R3
ST R4 SAVE_R4
ST R5 SAVE_R5
ST R6 SAVE_R6
ST R7 SAVE_R7
;
;行判断
;
JUDGE1 LD R0 TEMP0 ;R0 = index
LD R1 TEMP1 ;R1 = -value
NOT R1 R1
ADD R1 R1 #1
JSR div
LD R2 TEMP1 ;R2 = i
LD R3 TEMP2 ;R3 = j
AND R4 R4 #0 ;R4 = cnt
LEA R5 ARRAY ;R5 元素指针，从行首开始
ADD R5 R5 R0
NOT R6 R3
ADD R6 R6 #1
ADD R5 R5 R6
ST R5 TEMP3 ;行首指针存起来
;
;Loop: jump-tp-middle
;
BRnzp J_MIDD_1
J_LOOP_1 LDR R6 R5 #0
ADD R6 R6 R1
BRnp J_NOT_1
ADD R4 R4 #1
ADD R5 R5 #1
ADD R6 R4 #-4
BRz J_RET_TRUE
BRnzp J_MIDD_1
J_NOT_1 AND R4 R4 #0
ADD R5 R5 #1
J_MIDD_1 LD R6 TEMP3
ADD R6 R6 #5
NOT R6 R6
ADD R6 R6 #1
ADD R6 R6 R5
BRn J_LOOP_1
;
;列判断
;
JUDGE2 ADD R4 R0 #-16
ADD R4 R4 #-2
BRzp JUDGE3
LEA R5 ARRAY
ADD R5 R5 R0
LDR R6 R5 #6
ADD R6 R6 R1
BRnp JUDGE3
LDR R6 R5 #12
ADD R6 R6 R1
BRnp JUDGE3
LDR R6 R5 #18
ADD R6 R6 R1
BRnp JUDGE3
BRnzp J_RET_TRUE
;
;主对角线方向判断
;
JUDGE3 AND R4 R4 #0
ADD R4 R4 #1 ;cnt=1
ST R2 TEMP3 ;存储i
ST R3 TEMP4 ;存储j
J_3_LOOP_1 ADD R2 R2 #-1
BRn J_3_END_1
ADD R3 R3 #-1
BRn J_3_END_1
ST R2 TEMP0
JSR multi
LD R5 TEMP1
ADD R5 R5 R3
LEA R6 ARRAY
ADD R5 R5 R6
LDR R5 R5 #0
ADD R5 R5 R1
BRnp J_3_END_1
ADD R4 R4 #1
BRnzp J_3_LOOP_1
J_3_END_1 LD R2 TEMP3
LD R3 TEMP4
J_3_LOOP_2 ADD R2 R2 #1
ADD R5 R2 #-6
BRzp J_3_END_2
ADD R3 R3 #1
ADD R5 R3 #-6
BRzp J_3_END_2
ST R2 TEMP0
JSR multi
LD R5 TEMP1
ADD R5 R5 R3
LEA R6 ARRAY
ADD R5 R5 R6
LDR R5 R5 #0
ADD R5 R5 R1
BRnp J_3_END_2
ADD R4 R4 #1
BRnzp J_3_LOOP_2
J_3_END_2 ADD R4 R4 #-4
BRzp J_RET_TRUE
;
;副对角线方向判断
;
JUDGE4 AND R4 R4 #0
ADD R4 R4 #1 ;cnt=1
LD R2 TEMP3
LD R3 TEMP4
J_4_LOOP_1 ADD R2 R2 #-1
BRn J_4_END_1
ADD R3 R3 #1
ADD R5 R3 #-6
BRzp J_4_END_1
ST R2 TEMP0
JSR multi
LD R5 TEMP1
ADD R5 R5 R3
LEA R6 ARRAY
ADD R5 R5 R6
LDR R5 R5 #0
ADD R5 R5 R1
BRnp J_4_END_1
ADD R4 R4 #1
BRnzp J_4_LOOP_1
J_4_END_1 LD R2 TEMP3
LD R3 TEMP4
J_4_LOOP_2 ADD R2 R2 #1
ADD R5 R2 #-6
BRzp J_4_END_2
ADD R3 R3 #-1
BRn J_4_END_2
ST R2 TEMP0
JSR multi
LD R5 TEMP1
ADD R5 R5 R3
LEA R6 ARRAY
ADD R5 R5 R6
LDR R5 R5 #0
ADD R5 R5 R1
BRnp J_4_END_2
ADD R4 R4 #1
BRnzp J_4_LOOP_2
J_4_END_2 ADD R4 R4 #-4
BRzp J_RET_TRUE
AND R1 R1 #0
ST R1 TEMP0
BRnzp J_RET_FALSE
J_RET_TRUE NOT R1 R1
ADD R1 R1 #1 ;恢复value, return
ST R1 TEMP0
J_RET_FALSE LD R0 SAVE_R0 ; 被调用者恢复
LD R1 SAVE_R1
LD R2 SAVE_R2
LD R3 SAVE_R3
LD R4 SAVE_R4
LD R5 SAVE_R5
LD R6 SAVE_R6
LD R7 SAVE_R7
RET
;
;----------------------------------------------
;函数: 实现对6执行乘法的结果
;input: TEMP0
;output: TEMP1
;这里，单独设计一群寄存器保存multi和div函数，
;防止函数在嵌套时出现内存被篡改的现象
;
SAVE_R0_ .FILL #0
SAVE_R1_ .FILL #0
SAVE_R2_ .FILL #0
;
multi ST R0 SAVE_R0_ ;被调用者保存
ST R1 SAVE_R1_
ST R2 SAVE_R2_
LD R0 TEMP0
AND R1 R1 #0 ;返回值
BRnzp MUL_MIDDLE
MUL_LOOP ADD R1 R1 #6
ADD R0 R0 #-1
MUL_MIDDLE ADD R0 R0 #0
BRp MUL_LOOP
ST R1 TEMP1 ; 函数返回值
LD R0 SAVE_R0_ ; 被调用者恢复
LD R1 SAVE_R1_
LD R2 SAVE_R2_
RET
;
;函数：除法，获得非负数对6的积和余数
;input: TEMP0
;output: TEMP1, TEMP2
;
div ST R0 SAVE_R0_ ; 被调用者保存
ST R1 SAVE_R1_
ST R2 SAVE_R2_
LD R0 TEMP0 ;余数
AND R1 R1 #0 ;积
DIV_LOOP ADD R2 R0 #-6
BRn DIV_END
ADD R1 R1 #1
AND R0 R2 R2
BRp DIV_LOOP
DIV_END ST R1 TEMP1
ST R0 TEMP2
LD R0 SAVE_R0_ ; 被调用者恢复
LD R1 SAVE_R1_
LD R2 SAVE_R2_
RET
ENDLINE1 .FILL 0x0D
;
;main function
;
main AND R1 R1 #0
ADD R1 R1 #1 ;落子方标记，1=player1,-1=player2
MAIN_LOOP JSR print
JSR isTie
LD R2 TEMP1 ;R2用于胜负判断
ADD R2 R2 #0
BRnp tie
ADD R1 R1 #0
BRn P2_DO
P1_DO LEA R0 PLAY_1
TRAP x22
BRnzp MAIN_JUDGE
P2_DO LEA R0 PLAY_2
TRAP x22
MAIN_JUDGE TRAP x20
TRAP x21
ADD R0 R0 #-16
ADD R0 R0 #-16
ADD R0 R0 #-16 ;index = ascii_code - 48
ADD R3 R0 #-1 ;index in function is from 0 to 5 in every line
LD R0 ENDLINE1
TRAP x21
ST R3 TEMP0
ST R1 TEMP1 ;we need a input
ADD R1 R1 #0
BRn P2_DO_1
P1_DO_1 JSR play1
BRnzp P_DO_END1
P2_DO_1 JSR play2
P_DO_END1 LD R3 TEMP0
ADD R3 R3 #0
BRzp MAIN_RIGHT
MAIN_ERROR ;LEA R0 ERROR
;TRAP x22
BRnzp MAIN_LOOP
MAIN_RIGHT ST R1 TEMP1
ST R3 TEMP0
JSR isOver
LD R4 TEMP0
ADD R4 R4 #0
BRnp GAME_OVER
NOT R1 R1
ADD R1 R1 #1
BRnzp MAIN_LOOP
GAME_OVER JSR print
ADD R1 R1 #0
BRp p1_win
BRn p2_win
;
;三种结局，最终分别调用这三种函数
;
tie LEA R0 TIE
TRAP x22
HALT
p1_win LEA R0 P_1_WIN
TRAP x22
HALT
p2_win LEA R0 P_2_WIN
TRAP x22
HALT
;
;常用字符串和常量
;
PLAY_1 .STRINGZ "Player 1, choose a column: "
PLAY_2 .STRINGZ "Player 2, choose a column: "
P_1_WIN .STRINGZ "Player 1 Wins.\n"
P_2_WIN .STRINGZ "Player 2 Wins.\n"
TIE .STRINGZ "Tie Game.\n"
.END
