.data

board_data: .space 42

beg_msg_out: .asciiz "Test out\n"
nl_char: .asciiz "\n"
done_out: .asciiz "Done\n"
store_error_message: .asciiz "ERROR: Invalid storage location\n"

#Draw Board Data
board_edge_output: .asciiz "|"
board_empty_output: .asciiz "_|"
board_O_output: .asciiz "0|"
board_X_output: .asciiz "X|"
board_error_output: .asciiz "?|"
boardSpaceOutput: .asciiz " "

.text

j main
	.globl main		#player IDs: 1 = user, 2 = AI

	# Macros


	.macro setup_random
	li $v0, 30
	syscall
	move $a1, $a0
	li $a0, 0
	li $v0, 40
	syscall
.end_macro

.macro get_random_number(%max, %where)
	li $a1, %max
	li $a0, 0
	li $v0, 42
	syscall
	move %where, $a0
.end_macro

.macro GetAIPlaceMacro(%where)
	jal GetAIPlace
	move %where, $v0
.end_macro


GetAIPlace:
	addi $sp, $sp, -4
	sw $ra, 0($sp)
	get_random_number(2,$t0)
	beq $t0, 0 GetAIPlaceCenter
	get_random_number(2,$t0)
	beq $t0, 0 GetAIPlace1_5
	get_random_number(2,$t0)
	beq $t0, 0 GetAIPlace2_4
	j GetAIPlace0_6

GetAIPlaceCenter:
	li $v0, 3
	j GetAIPlaceReturn

GetAIPlace0_6:
	get_random_number(2,$t0)
	beq $t0, 0 GetAIPlace6
	li $v0, 0
	j GetAIPlaceReturn
	GetAIPlace6:
	li $v0, 6
	j GetAIPlaceReturn

GetAIPlace1_5:
	get_random_number(2,$t0)
	beq $t0, 0 GetAIPlace5
	li $v0, 1
	j GetAIPlaceReturn
	GetAIPlace5:
	li $v0, 5
	j GetAIPlaceReturn

GetAIPlace2_4:
	get_random_number(2,$t0)
	beq $t0, 0 GetAIPlace4
	li $v0, 2
	j GetAIPlaceReturn
	GetAIPlace4:
	li $v0, 4
	j GetAIPlaceReturn

GetAIPlaceReturn:
	lw $ra, 0($sp)
	addi $sp, $sp, 4
	jr $ra




	.macro Place (%user, %x)#tries to drop a piece at a column.
				#where user is the id of the player dropping the piece, and x is the column.
				#returns 0 if valid else 1 if the column is filled up at $v0.
	addi $a0, $zero, %user
	add $a1, $zero, %x
	jal PlacePiece
	.end_macro

	.macro getHeightMac(%x,%where)
	addi $a0, %x, 0
	jal GetHeight
	add %where, $v0, $zero
	.end_macro

	.macro exit_prog #Used to terminate the program
	li $v0, 10 #Let syscall know we want to terminate the program
	syscall #Exit program
	.end_macro #End exit_prog macro

	.macro load_gp_reg(%x, %y, %where)
	add $a0, $zero, %x
	add $a1, $zero, %y
	jal load_game_piece
	add %where, $v0, $zero
	.end_macro

	.macro PrintString (%str)#tries to print a string.
	.data
	string: .asciiz %str
	.text
	li $v0, 4
	la $a0, string
	syscall
	.end_macro

	.macro Print(%address)
	li $v0, 4
	la $a0, %address
	syscall
	.end_macro

	.macro PrintLine 	#tries to print a line return.
	.data
	string: .asciiz "\n"
	.text
	li $v0, 4
	la $a0, string
	syscall
	.end_macro

	.macro PrintInteger (%x)#tries to print an integer.
	li $v0, 1
	add $a0, $zero, %x
	syscall
	.end_macro

	.macro ReadInteger	#returns a user input integer at $v0.
	li	$v0,	5
	syscall
	#TODO fix invalid integer crashes.
	.end_macro

	.macro CheckWin	 	# Returns the id of the player that has won (or 0 if no one has won) at $v0.

	# Push stack
	add $sp, $sp, -36
	sw $ra, 0($sp)
	sw $s0, 4($sp)
	sw $s1, 8($sp)
	sw $s2, 12($sp)
	sw $s3, 16($sp)
	sw $s4, 20($sp)
	sw $s5, 24($sp)
	sw $s6, 28($sp)
	sw $s7, 32($sp)

	# Scan horizontally
	li $s1, 0 # x
	li $s2, 0 # y
	li $s3, 0 # Count
	li $s4, 0 # Last value
CWHorizontalLoop:
	load_gp_reg($s1, $s2, $s0)
	beq $s0, $s4, CWHorizontalSkipReset
	li $s3, 0
CWHorizontalSkipReset:
	addi $s3, $s3, 1
	add $s4, $zero, $s0
	sge $t0, $s3, 4
	sne $t1, $s4, 0
	and $t0, $t0, $t1
	beq $t0, 1, CWFoundWin
	addi $s1, $s1, 1
	blt $s1, 7, CWHorizontalLoopContinue
	li $s1, 0
	addi $s2, $s2, 1
	li $s3, 0
	li $s4, 0
CWHorizontalLoopContinue:
	blt $s2, 6, CWHorizontalLoop

	# Scan vertically
	li $s1, 0 # y
	li $s2, 0 # x
	li $s3, 0 # Count
	li $s4, 0 # Last value
CWVerticalLoop:
	load_gp_reg($s2, $s1, $s0)
	beq $s0, $s4, CWVerticalSkipReset
	li $s3, 0
CWVerticalSkipReset:
	addi $s3, $s3, 1
	add $s4, $zero, $s0
	sge $t0, $s3, 4
	sne $t1, $s4, 0
	and $t0, $t0, $t1
	beq $t0, 1, CWFoundWin
	addi $s1, $s1, 1
	blt $s1, 6, CWVerticalLoopContinue
	li $s1, 0
	addi $s2, $s2, 1
	li $s3, 0
	li $s4, 0
CWVerticalLoopContinue:
	blt $s2, 7, CWVerticalLoop

	# Scan diagonally
	li $s1, 0 # x
	li $s2, 2 # y
	li $s3, 0 # Upward right count
	li $s4, 0 # Upward right last value
	li $s5, 0 # Downward right count
	li $s6, 0 # Downward right last value
CWDiagonalLoop:
	load_gp_reg($s1, $s2, $s0)
	beq $s0, $s4, CWDiag1SkipReset
	li $s3, 0
	CWDiag1SkipReset:
	add $s4, $zero, $s0
	addi $s3, $s3, 1
	li $t0, 5
	sub $s7, $t0, $s2
	load_gp_reg($s1, $s7, $s0)
	beq $s0, $s6, CWDiag2SkipReset
	li $s5, 0
	CWDiag2SkipReset:
	add $s6, $zero, $s0
	addi $s5, $s5, 1
	sge $t0, $s3, 4
	sne $t1, $s4, 0
	and $t0, $t0, $t1
	beq $t0, 1, CWFoundWin
	sge $t0, $s5, 4
	sne $t1, $s6, 0
	and $t0, $t0, $t1
	beq $t0, 1, CWFoundWin2
	addi $s1, $s1, 1
	addi $s2, $s2, 1
	slti $t0, $s1, 7
	slti $t1, $s2, 6
	and $t0, $t0, $t1
	beq $t0, 1, CWDiagonalLoop
	bge $s1, $s2, CWDiagonalLatterHalf # x >= y
	sub $s2, $s2, $s1 # y = y - x
	addi $s2, $s2, -1 # y--
	li $s1, 0 # x = 0
	j CWDiagonalChecks
CWDiagonalLatterHalf:
	sub $s1, $s1, $s2 # x = x - y
	addi $s1, $s1, 1 # x++
	li $s2, 0 # y = 0
CWDiagonalChecks:
	li $s3, 0
	li $s4, 0
	li $s5, 0
	li $s6, 0
	seq $t0, $s1, 4
	seq $t1, $s2, 0
	and $t0, $t0, $t1
	beq $t0, 1, CWDiagonalEnd
	j CWDiagonalLoop
CWDiagonalEnd:

	j CWFoundNoWin
CWFoundWin:
	add $v0, $zero, $s4
	j CWEnd
CWFoundWin2:
	add $v0, $zero, $s6
	j CWEnd
CWFoundNoWin:
	li $v0, 0
CWEnd:
	# Pop stack
	lw $ra, 0($sp)
	lw $s0, 4($sp)
	lw $s1, 8($sp)
	lw $s2, 12($sp)
	lw $s3, 16($sp)
	lw $s4, 20($sp)
	lw $s5, 24($sp)
	lw $s6, 28($sp)
	lw $s7, 32($sp)
	add $sp, $sp, 36
	.end_macro



	main:
	setup_random
	PrintString("\n\nWelcome to Connect 4 the assembly game. Enter 0 to go first or 1 to go second: ")
	jal PlayOpeningSound
	ReadInteger()
	bgt $v0, $zero, enemy
	j user

	enemy: 		#it is the AI's turn.
	jal	AIMove
	move $s0, $v0
	move $s1, $v1
	bne $s0, -1, EnemyNotRandomAI
	bne $s1, -1, EnemyNotRandomAI
	EnemyRandomAI:
	GetAIPlaceMacro($s0)
	beq $s0, -1, EnemyRandomAI
	Place(2, $s0)
	j PlaceEnemyExit
	EnemyNotRandomAI:
	Place(2, $s0)
	PlaceEnemyExit:
	PrintString("Placing piece at ")
	PrintInteger($s0)
	PrintString(" ")
	PrintInteger($s1)
	PrintString("\n")
	PrintString("It is the AI's turn. They placed a piece at: ")
	PrintInteger($s0)
	PrintLine()
	jal draw_board
	CheckWin()
	bge $v0, 1, SomeoneWon
	j user

	user: 		#it is the user's turn.
	PrintString("It is your turn. Enter a number from 1 to 7 to place your chip: ")
	ReadInteger()
	li	$t1,	1
	slt	$t0,	$v0,	$t1
	bne	$t0,	$zero,	user
	li	$t1,	8
	slt	$t0,	$v0,	$t1
	beq	$t0,	$zero,	user
	addi	$v0,	$v0,	-1
	Place(1,$v0)
	beq	$v0,	-1,	user
	jal draw_board
	CheckWin()
	bge $v0, 1, SomeoneWon
	j enemy

	SomeoneWon:
	beq $v0, 2, AIWon
	PlayerWon:
	PrintString("Congratulations, you won!")
	jal PlayWinningSound
	exit_prog
	AIWon:
	PrintString("Sorry, you lost.")
	jal PlayLosingSound
	exit_prog

	.macro print_stored_int (%label) #Used to simplify output and make code look cleaner
	li $v0, 1 #Let syscall know we want to print an int
	la $t0, %label #Load the address of %label
	lw $a0, ($t0) #Load the int that %label points to
	syscall #Print the loaded int
	.end_macro #End print_stored_int macro

	.macro print_int(%reg)
	add $a0, %reg, $zero
	li $v0, 1 #Let syscall know we want to print an int
	syscall
	.end_macro

	.macro store_gp(%x, %y, %value)
	addi $a0, $zero, %x
	addi $a1, $zero, %y
	addi $a2, $zero, %value
	jal store_game_piece
	.end_macro

	.macro load_gp(%x, %y, %where)
	addi $a0, $zero, %x
	addi $a1, $zero, %y
	jal load_game_piece
	add %where, $v0, $zero
	.end_macro

	.macro store_gp_reg(%x, %y, %value)
	add $a0, $zero, %x
	add $a1, $zero, %y
	add $a2, $zero, %value
	jal store_game_piece
	.end_macro


draw_board:
	add $sp, $sp, -20
	sw $ra, 0($sp)
	sw $s0, 4($sp)
	sw $s1, 8($sp)
	sw $s2, 12($sp)
	sw $s3, 16($sp)
	addi $s0, $zero, 6 #y value max
	addi $s1, $zero, 7 #x value max
	addi $s2, $zero, 0 #y value
	addi $s3, $zero, 0 #x value
	li $t0, 0
	DrawBoardNumbersLoop: # Number header
	addi $t0, $t0, 1
	Print(boardSpaceOutput)
	print_int($t0)
	blt $t0, $s1, DrawBoardNumbersLoop
	PrintLine()
	draw_board_loop_y:
		bge $s2, $s0, draw_board_return
		Print(board_edge_output)
		addi $s3, $zero, 0 #x value
		draw_board_loop_x:
			bge $s3, $s1, draw_board_loop_x_exit
			addi $t3, $zero, 5
			sub $t2, $t3, $s2
			load_gp_reg($s3,$t2,$t0)
			beq $t0, 0, draw_board_empty
			beq $t0, 1, draw_board_x
			beq $t0, 2, draw_board_o
			j draw_board_error
			draw_board_loop_return:
			addi $s3, $s3, 1
			j draw_board_loop_x
		draw_board_loop_x_exit:
		addi $s2, $s2, 1
		PrintLine()
		j draw_board_loop_y

draw_board_return:
	lw $ra, 0($sp)
	lw $s0, 4($sp)
	lw $s1, 8($sp)
	lw $s2, 12($sp)
	lw $s3, 16($sp)
	add $sp, $sp, 20 #Pop stack
	jr $ra

#Board Draws
draw_board_x:
Print(board_X_output)
j draw_board_loop_return

draw_board_o:
Print(board_O_output)
j draw_board_loop_return

draw_board_error:
Print(board_error_output)
j draw_board_loop_return

draw_board_empty:
Print(board_empty_output)
j draw_board_loop_return
#Board Draws END


#reset board
#Resets all board values to 0x00
reset_board:
	add $t0, $a0, $zero
	add $t1, $a1, $zero
	add $sp, $sp, -4
	sw $ra, 0($sp)
	li $t2, 0
reset_board_loop:
		bge $t2, $t0, reset_board_exit
		add $t3, $t1, $t2
		sb $zero, 0($t3)
		add $t2, $t2, 1
		j reset_board_loop
reset_board_exit:
	lw $ra, 0($sp)
	add $sp, $sp, 4
	jr $ra

#Save game piece
#param($a0) : x position
#param($a1) : y position
#param($a2) : value to store
#If an invalid position is given, will exit and print error message
store_game_piece:
	add $sp, $sp, -4 #Push stack
	sw $ra, 0($sp)
	add $t0, $a0, $zero
	add $t1, $a1, $zero
	add $t2, $a2, $zero
	#error checking
	bge $t0, 7, save_game_piece_error
	bge $t1, 6, save_game_piece_error
	blt $t0, 0, save_game_piece_error
	blt $t1, 0, save_game_piece_error
	#error checking end
	li $t9, 7 #Place 7 for multiplacation factor
	mult $t1, $t9 #Multiply 7 * y value given
	mflo $t3 #Get multiplacation answer
	la $t4, board_data #grab board address
	add $t8, $t3, $t0 #add x to multiplacation answer
	add $t8, $t4, $t8 #add offset to board address
	sb $t2, 0($t8) #Store value given
save_game_piece_return:
	lw $ra, 0($sp)
	add $sp, $sp, 4 #Pop stack
	jr $ra
save_game_piece_error:
	Print(store_error_message)
	j save_game_piece_return




#Load game piece
#param($a0) : x position
#param($a1) : y position
#return($v0) : Either value stored in location or -1 if error
load_game_piece:
	add $sp, $sp, -4
	sw $ra, 0($sp)

	add $t0, $a0, $zero
	add $t1, $a1, $zero
	#error checking
	bge $t0, 7, load_game_piece_error
	bge $t1, 6, load_game_piece_error
	blt $t0, 0, load_game_piece_error
	blt $t1, 0, load_game_piece_error
	#error checking end
	li $t8, 7 #Place 7 for multiplacation factor
	mult $t1, $t8 #Multiply 7 * y value given
	mflo $t2 #Get multiplacation answer
	la $t3, board_data #grab board address
	add $t9, $t2, $t0 #add x to multiplacation answer
	add $t4, $t3, $t9 #add offset to board address
	lb $v0, 0($t4) #Load value in memory location
load_game_piece_return:
	lw $ra, 0($sp)
	add $sp, $sp, 4 #Pop stack
	jr $ra
load_game_piece_error:
	addi $v0, $zero, -1
	j load_game_piece_return


#Get height
GetHeight:
	addi $sp, $sp, -12
	sw $ra, 0($sp)
	sw $s0, 4($sp)
	sw $s1, 8($sp)
	add $s0, $zero, $a0
	add $s1, $zero, 5 #Down counter
	GetHeightLoop:
		beq $s1, -1, GetHeightReturn
		load_gp_reg($s0,$s1,$t0)
		bge $t0, 1, GetHeightReturn
		addi $s1, $s1, -1
		j GetHeightLoop



GetHeightReturn:
	addi $v0, $s1, 1
	lw $ra, 0($sp)
	lw $s0, 4($sp)
	lw $s1, 8($sp)
	addi $sp, $sp, 12
	jr $ra



PlacePiece:
	addi $sp, $sp, -16
	sw $ra, 0($sp)
	sw $s0, 4($sp)
	sw $s1, 8($sp)
	sw $s2, 12($sp)
	add $s0, $zero, $a0 #player
	add $s1, $zero, $a1 #Col
	add $s2, $zero, 5 #Down counter
	bge $s1, 7, PlacePieceError
	load_gp_reg($s1,$s2,$t0)
	bge $t0, 1, PlacePieceError
	addi $s2, $s2, -1
	PlacePieceLoop:
		beq $s2, -1, PlacePieceSucc
		load_gp_reg($s1,$s2,$t0)
		bge $t0, 1, PlacePieceSucc
		addi $s2, $s2, -1
		j PlacePieceLoop


PlacePieceError:
	bne $s0, 1, PlacePieceErrorContinue # Only play sound if it's a player move.
	jal PlayNegativeSound
PlacePieceErrorContinue:
	addi $v0, $zero, -1
	j PlacePieceReturn

PlacePieceSucc:
	bne $s0, 1, PlacePieceSuccContinue # Only play sound if it's a player move.
	jal PlayPositiveSound
PlacePieceSuccContinue:
	addi $s2, $s2, 1
	store_gp_reg($s1,$s2,$s0)
	addi $v0, $zero, 1
	j PlacePieceReturn

PlacePieceReturn:
	lw $ra, 0($sp)
	lw $s0, 4($sp)
	lw $s1, 8($sp)
	lw $s2, 12($sp)
	addi $sp, $sp, 16
	jr $ra

	# Sounds

	.macro setUpSound
	li $a2, 114 # Instrument: steel drums
	li $a3, 63 # Volume: half
	.end_macro

	.macro playSound(%note, %duration, %isSyncronous)
	li $v0, 31
	li $t0, %isSyncronous
	sll $t0, $t0, 1
	add $v0, $v0, $t0
	li $a0, %note
	li $a1, %duration
	syscall
	.end_macro

PlayOpeningSound:
	setUpSound
	playSound(72, 100, 1) # C for 0.1 sec
	playSound(76, 100, 1) # E for 0.1 sec
	playSound(79, 800, 0) # G for 0.8 sec
	jr $ra

PlayPositiveSound:
	setUpSound
	playSound(76, 1000, 0) # E for 1 sec
	jr $ra

PlayNegativeSound:
	setUpSound
	playSound(72, 1000, 0) # C and C# for 1 sec
	playSound(73, 1000, 0)
	jr $ra

PlayWinningSound:
	setUpSound
	playSound(79, 100, 1) # G for 0.1 sec
	playSound(79, 900, 0) # G for 0.9 sec
	jr $ra

PlayLosingSound:
	setUpSound
	playSound(75, 250, 1) # Eb for 0.25 sec
	playSound(74, 250, 1) # D for 0.25 sec
	playSound(72, 500, 0) # E for 0.5 sec
	jr $ra





AIMove:
	addi	$sp,	$sp,	-28
	sw	$ra,	0($sp)
	sw	$s0,	4($sp)
	sw	$s1,	8($sp)
	sw	$s2,	12($sp)
	sw	$s3,	16($sp)
	sw	$s4,	20($sp)
	sw	$s5,	24($sp)
	#Code Stuff
	li $s0, 0 #X variable
	AIMoveXLoop:
		li $s1, 0 #Y variable
		AIMoveYLoop:
		move $a0, $s0
		move $a1, $s1
		jal AICheckU
		bne $v0, -1, AIMoveReturn
		move $a0, $s0
		move $a1, $s1
		jal AICheckR
		bne $v0, -1, AIMoveReturn
		move $a0, $s0
		move $a1, $s1
		jal AICheckL
		bne $v0, -1, AIMoveReturn
		move $a0, $s0
		move $a1, $s1
		jal AICheckLU
		bne $v0, -1, AIMoveReturn
		addi $s1, $s1, 1
		blt $s1, 6, AIMoveYLoop
	addi $s0, $s0, 1
	blt $s0, 7, AIMoveXLoop
	li $v0, -1
	li $v1, -1
	j AIMoveReturn

AIMoveReturn:
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	lw	$s3,	16($sp)
	lw	$s4,	20($sp)
	lw	$s5,	24($sp)
	addi	$sp,	$sp,	28
	jr $ra




#$a0 is x(index), $a1 is y(index)
#$v0 is x in question
#$v1 is y in question
AICheckU:
	addi	$sp,	$sp,	-16
	sw	$ra,	0($sp)
	sw	$s0,	4($sp)
	sw	$s1,	8($sp)
	sw	$s2,	12($sp)
	move $s0, $a0	#X
	move $s1, $a1	#y
	load_gp_reg($s0,$s1,$s2)
	bne $s2, 1, AICheckUReturnUnFlagged
	addi $s1,$s1,1
	load_gp_reg($s0,$s1,$s2)
	bne $s2, 1, AICheckUReturnUnFlagged
	addi $s1,$s1,1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckUReturnFlagged
	beq $s2, 2, AICheckUReturnUnFlagged
	addi $s1,$s1,1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckUReturnFlagged
	j AICheckUReturnUnFlagged


AICheckUReturnFlagged:
	move $v0, $s0
	move $v1, $s1
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	jr $ra
AICheckUReturnUnFlagged:
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	li $v0, -1
	li $v1, -1
	jr $ra

#$a0 is x(index), $a1 is y(index)
#$v0 is x in question
#$v1 is y in question
AICheckR:
	addi	$sp,	$sp,	-16
	sw	$ra,	0($sp)
	sw	$s0,	4($sp)
	sw	$s1,	8($sp)
	sw	$s2,	12($sp)
	move $s0, $a0	#X
	move $s1, $a1	#y
	load_gp_reg($s0,$s1,$s2)
	bne $s2, 1, AICheckRReturnUnFlagged
	addi $s0,$s0,1
	load_gp_reg($s0,$s1,$s2)
	bne $s2, 1, AICheckRReturnUnFlagged
	addi $s0,$s0,1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckRReturnFlagged
	beq $s2, 2, AICheckRReturnUnFlagged
	addi $s0,$s0,1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckRReturnFlagged
	j AICheckRReturnUnFlagged


AICheckRReturnFlagged:
	getHeightMac($s0,$t0)
	bne $s1, $t0, AICheckRReturnUnFlagged
	move $v0, $s0
	move $v1, $s1
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	jr $ra
AICheckRReturnUnFlagged:
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	li $v0, -1
	li $v1, -1
	jr $ra


#$a0 is x(index), $a1 is y(index)
#$v0 is x in question
#$v1 is y in question
AICheckL:
	addi	$sp,	$sp,	-16
	sw	$ra,	0($sp)
	sw	$s0,	4($sp)
	sw	$s1,	8($sp)
	sw	$s2,	12($sp)
	move $s0, $a0	#X
	move $s1, $a1	#y
	load_gp_reg($s0,$s1,$s2)
	PrintInteger($s2)
	bne $s2, 1, AICheckLReturnUnFlagged
	PrintString("R Test\n")
	addi $s0,$s0,-1
	load_gp_reg($s0,$s1,$s2)
	bne $s2, 1, AICheckLReturnUnFlagged
	addi $s0,$s0,-1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckLReturnFlagged
	beq $s2, 2, AICheckLReturnUnFlagged
	addi $s0,$s0,-1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckLReturnFlagged
	j AICheckLReturnUnFlagged


AICheckLReturnFlagged:
	getHeightMac($s0,$t0)
	PrintString("Found Thingy\n")
	bne $s1, $t0, AICheckLReturnUnFlagged
	PrintString("Found Thingy OH NOOOOOO\n")
	move $v0, $s0
	move $v1, $s1
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	jr $ra
AICheckLReturnUnFlagged:
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	li $v0, -1
	li $v1, -1
	jr $ra



AICheckLU:
	addi	$sp,	$sp,	-16
	sw	$ra,	0($sp)
	sw	$s0,	4($sp)
	sw	$s1,	8($sp)
	sw	$s2,	12($sp)
	move $s0, $a0	#X
	move $s1, $a1	#y
	load_gp_reg($s0,$s1,$s2)
	PrintInteger($s2)
	bne $s2, 1, AICheckLUReturnUnFlagged
	PrintString("R Test\n")
	addi $s0,$s0,-1
	addi $s1,$s1, 1
	load_gp_reg($s0,$s1,$s2)
	bne $s2, 1, AICheckLUReturnUnFlagged
	addi $s0,$s0,-1
	addi $s1,$s1, 1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckLUReturnFlagged
	beq $s2, 2, AICheckLUReturnUnFlagged
	addi $s0,$s0,-1
	addi $s1,$s1, 1
	load_gp_reg($s0,$s1,$s2)
	beq $s2, 0, AICheckLUReturnFlagged
	j AICheckLUReturnUnFlagged


AICheckLUReturnFlagged:
	getHeightMac($s0,$t0)
	PrintString("Found Thingy\n")
	bne $s1, $t0, AICheckLUReturnUnFlagged
	PrintString("Found Thingy OH NOOOOOO\n")
	move $v0, $s0
	move $v1, $s1
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	jr $ra
AICheckLUReturnUnFlagged:
	lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	addi	$sp,	$sp,	16
	li $v0, -1
	li $v1, -1
	jr $ra





AIMoveOld:		#returns the column that the ai wants to drop the piece in at $v0.
	addi	$sp,	$sp,	-28
	sw	$ra,	0($sp)
	sw	$s0,	4($sp)
	sw	$s1,	8($sp)
	sw	$s2,	12($sp)
	sw	$s3,	16($sp)
	sw	$s4,	20($sp)
	sw	$s5,	24($sp)
	li 	$s1,	0		#i=0
fori:	bgt	$s1,	5,	efori	#i<rows
		li 	$s2,	0		#j=0
	forj:	bgt	$s2,	6,	eforj	#j<columns
			li 	$s3,	0		#vi=0
		forvi:	bgt	$s3,	1,	eforvi	#vi<2
				li 	$s4,	0		#vj=0
			forvj:	bgt	$s4,	1,	eforvj	#vj<2
				bne	$s3,	0,	and99	#if(vj!=0 | vi!=0)
				bne	$s4,	0,	and99
				j	eforv
			and99:
				li	$s0,	0		#counter = 0
					li 	$s5,	0		#v=0
				forv:	bgt	$s5,	3,	eforv	#v<4
						mul	$t1,	$s3,	$s5	#v*vi
						mul	$t2,	$s4,	$s5	#v*vj
						add	$t1,	$s1,	$t1	#i+v*vi
						add	$t2,	$s2,	$t2	#j+v*vj
						#j	eif98
						load_gp_reg($t1,$t2,$t3)	#ID = pieces[i+v*vi,j+v*vj]
						beq	$t3,	1,	if99	#if(ID==1)
						li	$s0,	0		#false: counter = 0
						j	eif99
					if99:	addi	$s0,	$s0,	1	#true: counter++
					eif99:	blt	$s0,	2,	eif98	#if(counter >= 2){
							addi	$v0,	$t2,	0	#return j+(v+1)*vj
							j return9
							addi	$t3,	$s5,	1	#v+1
							mul	$t1,	$s3,	$t3	#(v+1)*vi
							mul	$t2,	$s4,	$t3	#(v+1)*vj
							add	$s7,	$s1,	$t1	#i+(v+1)*vi
							add	$s6,	$s2,	$t2	#j+(v+1)*vj
							addi	$s6,	$s6,	1
							getHeightMac($s6,$t3)		#height(j+(v+1)*vj)
							addi	$s6,	$s6,	-2
							bne,	$t3,	$s7,	eif97	#if(height(j+(v+1)*vj)==i+(v+1)*vi){
								PrintString("detected an attempt to win")
								PrintInteger($s6)
								PrintLine()
								addi	$v0,	$s6,	0	#return j+(v+1)*vj
								j return9		#}
						eif97:	sub	$t3,	$s5,	$s0	#v-counter
							mul	$t1,	$s3,	$t3	#(v-counter)*vi
							mul	$t2,	$s4,	$t3	#(v-counter)*vj
							add	$s7,	$s1,	$t1	#i+(v-counter)*vi
							add	$s6,	$s2,	$t2	#j+(v-counter)*vj
							addi	$s6,	$s6,	1
							getHeightMac($s6,$t3)		#height(j+(v-counter)*vj)
							addi	$s6,	$s6,	-2
							bne,	$t3,	$s7,	eif98	#if(height(j+(v-counter)*vj)==i+(v-counter)*vi){
								PrintString("detected an attempt to win")
								PrintInteger($s6)
								PrintLine()
								addi	$v0,	$s6,	0	#return j+(v-counter)*vj
								j return9
					eif98:					#}}
					addi	$s5,	$s5,	1	#v++
					j	forv
				eforv:
				addi	$s4,	$s4,	1	#vj++
				j	forvj
			eforvj:
			addi	$s3,	$s3,	1	#vi++
			j	forvi
		eforvi:
		addi	$s2,	$s2,	1	#j++
		j	forj
	eforj:
	addi	$s1,	$s1,	1	#i++
	j	fori
efori:	li	$v0,	3		#if nothing interesting is found, drop in center
return9:lw	$ra,	0($sp)
	lw	$s0,	4($sp)
	lw	$s1,	8($sp)
	lw	$s2,	12($sp)
	lw	$s3,	16($sp)
	lw	$s4,	20($sp)
	lw	$s5,	24($sp)
	addi	$sp,	$sp,	28
	jr	$ra