基于LC3模拟器的简单游戏设计：简易四子棋

一、实验目的

1. 分析和理解指定的需解决问题。
2. 利用LC-3的汇编代码设计实现相关程序。
3. 通过LC-3仿真器调试和运行相关程序并得到正确的结果。

二、实验内容

四子棋是一款普遍流行的简易型桌面游戏，据说，虎克船长曾因专注于此游戏而长期隐身在住所，当船员们发现船长的这一专长之后，他们称这个游戏为“船长的情妇”。

四子棋是个双人游戏，两人轮流下棋，棋盘由行和列组成的网格，每个选手每次下一个子直到两人中有一人的棋子连成一条水平线、垂直线或者是对角线。

本实验需要在LC-3中实现简易版四子棋的游戏，两位选手通过键盘和输出窗口轮流交互操作，棋盘由6 X 6的网格组成。

游戏规则如下：

1. 两位选手依次轮流落子；
2. 选手不能悔棋；
3. 有子的地方不能继续落子；
4. 直到有一方的四个棋子能够连成一条水平线、垂直线或者是对角线；
5. 如果棋盘已满，无人获胜，则平局。

游戏最初时应该打印空的棋盘，可以用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