# limited move options

global pieceValTenjiku = Dict{String, Int64}("bishop" => 10, "bishop general" => 21, "blind tiger" => 3, "copper general" => 2, "chariot soldier" => 18, "dog" => 1, "drunk elephant" => 3, "dragon horse" => 12, "dragon king" => 14, "ferocious leopard" => 3, "flying ox" => 16, "flying stag" => 9, "fire demon" => 83, "free boar" => 16, "free eagle" => 22, "gold general" => 3, "great general" => 45, "heavenly tetrarch" => 12, "horned falcon" => 19, "iron general" => 2, "king" => 500, "kirin" => 3, "lance" => 6, "lion hawk" => 25, "lion" => 18, "multi general" => 6, "knight" => 1, "pawn" => 1, "phoenix" => 3, "queen" => 22, "rook" => 12, "reverse chariot" => 6, "rook general" => 23, "silver general" => 2, "soaring eagle" => 18, "side mover" => 7, "side soldier" => 7, "vice general" => 39, "vertical mover" => 7, "vertical soldier" => 8, "water buffalo" => 17, "whale" => 10, "white horse" => 14)

global rangeJumpPriority = Dict{String, Int64}("_" => 0, "bishop" => 0, "bishop general" => 1, "blind tiger" => 0, "copper general" => 0, "chariot soldier" => 0, "dog" => 0, "drunk elephant" => 0, "dragon horse" => 0, "dragon king" => 0, "ferocious leopard" => 0, "flying ox" => 0, "flying stag" => 0, "fire demon" => 0, "free boar" => 0, "free eagle" => 0, "gold general" => 0, "great general" => 3, "heavenly tetrarch" => 0, "horned falcon" => 0, "iron general" => 0, "king" => 4, "kirin" => 0, "lance" => 0, "lion hawk" => 0, "lion" => 0, "multi general" => 0, "knight" => 0, "pawn" => 0, "phoenix" => 0, "queen" => 0, "rook" => 0, "reverse chariot" => 0, "rook general" => 1, "silver general" => 0, "soaring eagle" => 0, "side mover" => 0, "side soldier" => 0, "vice general" => 2, "vertical mover" => 0, "vertical soldier" => 0, "water buffalo" => 0, "whale" => 0, "white horse" => 0)

global pieceValChu = Dict{String, Int64}("lion" => 20, "queen" => 12, "dragon king" => 8, "soaring eagle" => 11, "dragon horse" => 7, "horned falcon" => 10, "rook" => 6, "bishop" => 5, "vertical mover" => 4, "flying ox" => 8, "side mover" => 4, "free boar" => 8, "king" => 50, "phoenix" => 3, "kirin" => 3, "reverse chariot" => 3, "whale" => 5 , "lance" => 3, "white horse" => 7, "drunk elephant" => 3, "gold general" => 3, "ferocious leopard" => 3, "blind tiger" => 3, "flying stag" => 6, "silver general" => 2, "copper general" => 2, "go between" => 1, "pawn" => 1)

global pieceVal = Dict{String,Int64}("pawn"=>1, "pawn promoted" =>2, "lance" =>4, "lance promomted" =>5, "knight" =>6,
"knight promoted" =>7, "silver general" =>7,"silver general promoted" =>8, "gold general" =>8, "bishop" =>11, "rook" =>13, "bishop promoted" =>15, "rook promoted" =>17, "king"=>50)

global prStandard = Dict{String, String}("rook promoted" => "dragon king","bishop promoted" => "dragon horse","silver general promoted" => "gold general",
 	"knight promoted" => "gold general", "lance promoted" => "gold general", "pawn promoted" => "gold general")
global prTenjiku = Dict{String,String}("bishop promoted" => "dragon horse", "bishop general promoted" => "vice general",

#global tempMoveChoice2 = Array{Int64}(8) # Only used for double captures
global strength = -1
global whitePrison = []
global blackPrison = []
global chessboard
global tempChessboard

global currTurn

type moveOffset
	row::Int64
	col::Int64
end

type piece
	display::String

				chessboard[i, j].WAttack = 0
				chessboard[i, j].BAttack = 0
			end
		end
	end
	for i in 1:dim
		for j in 1:dim
			if chessboard[i, j].side == currTurn
				if chessboard[i, j].name == defBishop
					defBishopMove(i, j, option)
				elseif chessboard[i, j].name == defBishopGeneral
					defBishopGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defBlindTiger
					defBlindTigerMove(i, j, option)
				elseif chessboard[i, j].name == defCopperGeneral
					defCopperGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defChariotSoldier
					defChariotSoldierMove(i, j, option)
				elseif chessboard[i, j].name == defDog
					defDogMove(i, j, option)
				elseif chessboard[i, j].name == defDrunkElephant
					defDrunkElephantrMove(i, j, option)
				elseif chessboard[i, j].name == defDragonHorse
					defDragonHorseMove(i, j, option)
				elseif chessboard[i, j].name == defDragonKing
					defDragonKingMove(i, j, option)
				elseif chessboard[i, j].name == defFerociousLeopard
					defFerociousLeopardMove(i, j, option)
				elseif chessboard[i, j].name == defFireDemon
					defFireDemonMove(i, j, option)
				elseif chessboard[i, j].name == defFlyingOx
					defFlyingOxMove(i, j, option)
				elseif chessboard[i, j].name == defFlyingStag
					defFlyingStagMove(i, j, option)
				elseif chessboard[i, j].name == defFreeBoar
					defFreeBoarMove(i, j, option)
				elseif chessboard[i, j].name == defFreeEagle
					defFreeEagleMove(i, j, option)
				elseif chessboard[i, j].name == defGoldGeneral
					defGoldGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defGreatGeneral
					defGreatGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defHeavenlyTetrarch
					defHeavenlyTetrarchMove(i, j, option)
				elseif chessboard[i, j].name == defHornedFalcon
					defHornedFalconMove(i, j, option)
				elseif chessboard[i, j].name == defIronGeneral
					defIronGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defKing
					defKingMove(i, j, option)
				elseif chessboard[i, j].name == defKirin
					defKirinMove(i, j, option)
				elseif chessboard[i, j].name == defLance
					defLanceMove(i, j, option)
				elseif chessboard[i, j].name == defLionHawk
					defLionHawkMove(i, j, option)
				elseif chessboard[i, j].name == defLion
					defLionMove(i, j, option)
				elseif chessboard[i, j].name == defMultiGeneral
					defMultiGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defKnight
					defKnightMove(i, j, option)
				elseif chessboard[i, j].name == defPawn
					defPawnMove(i, j, option)
				elseif chessboard[i, j].name == defPhoenix
					defPhoenixMove(i, j, option)
				elseif chessboard[i, j].name == defQueen
					defQueenMove(i, j, option)
				elseif chessboard[i, j].name == defRook
					defRookMove(i, j, option)
				elseif chessboard[i, j].name == defReverseChariot
					defReverseChariotMove(i, j, option)
				elseif chessboard[i, j].name == defRookGeneral
					defRookGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defSilverGeneral
					defGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defSoaringEagle
					defSoaringEagleMove(i, j, option)
				elseif chessboard[i, j].name == defSideMover
					defSideMoverMove(i, j, option)
				elseif chessboard[i, j].name == defSideSoldier
					defSideSoldierMove(i, j, option)
				elseif chessboard[i, j].name == defViceGeneral
					defViceGeneralMove(i, j, option)
				elseif chessboard[i, j].name == defVerticalMover
					defVerticalMoverMove(i, j, option)
				elseif chessboard[i, j].name == defVerticalSoldier
					defVerticalSoldierMove(i, j, option)
				elseif chessboard[i, j].name == defWaterBuffalo
					defWaterBuffaloMove(i, j, option)
				elseif chessboard[i, j].name == defWhale
					defWhaleMove(i, j, option)
				elseif chessboard[i, j].name == defWhiteHorse
					defWhiteHorseMove(i, j, option)
				end
			end
		end
	end
end

function update(srcRow::Int64, srcCol::Int64, destRow::Int64, destCol::Int64, option::String)
	global tempChessboard

	#	push!(capturedArray, captured.name)
	#	return false
	end
	return false
end

# Copy move into moveChoice if it is better
function demonBurn(srcRow::Int64, srcCol::Int64, destRow::Int64, destCol::Int64, temp::Int64)
	for i in 1:9
		tempRow = destRow + moveOption[i].row
		tempCol = destCol + moveOption[i].col
		if tempRow <= dim && tempRow >= 1 && tempCol <= dim && tempCol >= 1
			if chessboard[tempRow, tempCol].side != defDummy && chessboard[srcRow, srcCol].side != chessboard[tempRow, tempCol].side
				temp += pieceValTenjiku[chessboard[tempRow, tempCol].name]
			end
		end
	end
	return temp
end

# tempMoveChoice[1] is going to store the type of attack, 1 = single capture, 2 = double capture, 3 = vice general/fire demon
# Have not coded changing capturing chessboard
function capture(tempMoveChoice)
	a = 0
	b = 0
	global strength
	global moveChoice
	temp = -1
	if tempMoveChoice[1] == 1
		a = 4
		b = 5
	elseif tempMoveChoice[1] == 3
		a = 8
		b = 9
		while tempMoveChoice[a] == 0 && tempMoveChoice[b] == 0
			a -= 2
			b -= 2
		end
	end
	if tempMoveChoice[1] == 1 || tempMoveChoice[1] == 3
		if dim == tDim
			temp = pieceValTenjiku[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name] - pieceValTenjiku[chessboard[tempMoveChoice[2], tempMoveChoice[3]].name]
			if chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defFireDemon
				temp = demonBurn(tempMoveChoice[2], tempMoveChoice[3], tempMoveChoice[a], tempMoveChoice[b], temp)
			end		
		elseif dim == cDim
			temp = pieceValChu[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name] - pieceValTenjiku[chessboard[tempMoveChoice[2], tempMoveChoice[3]].name]
		else
			temp = pieceVal[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name] - pieceValTenjiku[chessboard[tempMoveChoice[2], tempMoveChoice[3]].name]
		end
		if chessboard[tempMoveChoice[2], tempMoveChoice[3]].side == defBlack # check if attack is safe
			if chessboard[tempMoveChoice[a], tempMoveChoice[b]].WAttack == 0
				if chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defKing && dim == tDim
					temp += 600
				elseif chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defKing && dim == cDim
					temp += 91
				elseif chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defKing
					temp += 68
				elseif dim == tDim
					temp += 500
				else
					temp += 50
				end
			end
		elseif chessboard[tempMoveChoice[2], tempMoveChoice[3]].side == defWhite
			if chessboard[tempMoveChoice[a], tempMoveChoice[b]].BAttack == 0
				if chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defKing && dim == tDim
					temp += 600
				elseif chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defKing && dim == cDim
					temp += 91
				elseif chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defKing
					temp += 68
				elseif dim == tDim
					temp += 500
				else
					temp += 50
				end
			end
		end
	elseif tempMoveChoice[1] == 2
		a = 4
		b = 5
		while tempMoveChoice[a] != 0 && tempMoveChoice[b] != 0
			if chessboard[tempMoveChoice[a], tempMoveChoice[b]] != defDummy
				if dim == tDim
					if temp == -1
						temp = pieceValTenjiku[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name] - pieceValTenjiku[chessboard[tempMoveChoice[2], tempMoveChoice[3]].name]
					else
						temp += pieceValTenjiku[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name]	
					end
				elseif dim == cDim
					if temp == -1
						temp = pieceValChu[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name] - pieceValTenjiku[chessboard[tempMoveChoice[2], tempMoveChoice[3]].name]
					else
						temp += pieceValChu[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name]
					end
				else
					if temp == -1
						temp = pieceVal[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name] - pieceValTenjiku[chessboard[tempMoveChoice[2], tempMoveChoice[3]].name]
					else
						temp += pieceVal[chessboard[tempMoveChoice[a], tempMoveChoice[b]].name]
					end
				end
			end
			if tempMoveChoice[a + 2] == 0 && tempMoveChoice[b + 2] == 0
				if chessboard[tempMoveChoice[a], tempMoveChoice[b]].side == defWhite # check if attack is safe
					if chessboard[tempMoveChoice[a], tempMoveChoice[b]].WAttack == 0
						if chessboard[tempMoveChoice[2], tempMoveChoice[3]].name == defKing && dim == tDim
							temp += 600

						end
					end
				end
			end
			a += 2
			b += 2
		end






	end




	println(strength)






	println(tempMoveChoice)




























	if temp > strength
		storeMoveChoice = [tempMoveChoice[2], tempMoveChoice[3], tempMoveChoice[4], tempMoveChoice[5], tempMoveChoice[6], tempMoveChoice[7], tempMoveChoice[8], tempMoveChoice[9]]
		strength = temp
		moveChoice = deepcopy(tempMoveChoice)
		#println(strength)
		#println(moveChoice)
	end
end

function step(srcRow::Int64, srcCol::Int64, option::String, destRow::Int64, destCol::Int64)
	if destRow <= dim && destRow >= 1 && destCol <= dim && destCol >= 1
		if option == "update"
			update(srcRow, srcCol, destRow, destCol, option)
		end
		if option == "capture"
			if chessboard[srcRow, srcCol].side != chessboard[destRow, destCol] && chessboard[destRow, destCol].side != defDummy
				tempMoveChoice = [1, srcRow, srcCol, destRow, destCol, 0, 0, 0, 0]
				capture(tempMoveChoice)
			end
		end
	end
end

function stepMultiple(srcRow::Int64, srcCol::Int64, option::String, tempRow::Int64, tempCol::Int64, jumps::Int64, tempMoveChoice)
	global tempChessboard
	a = 0
	b = 0
	if jumps == 0

		return
	end
	saveMoveChoice = deepcopy(tempMoveChoice)
	for i in 1:9
		if (chessboard[srcRow, srcCol].name == defFreeEagle && (i == 1 || i == 3 || i == 7 || i == 9)) || (chessboard[srcRow, srcCol].name != defFreeEagle && i != 5)


			tempMoveChoice = deepcopy(saveMoveChoice)


			newTempRow = tempRow + moveOption[i].row
			newTempCol = tempCol + moveOption[i].col
			if newTempRow <= dim && newTempRow >= 1 && newTempCol <= dim && newTempCol >= 1
				if option == "special update" || option == "demon update"
					update(srcRow, srcCol, newTempRow, newTempCol, option)
				end
				if option == "capture"
					a = 4
					b = 5
					while tempMoveChoice[a] != 0 && tempMoveChoice[b] != 0
						a += 2
						b += 2
					end
					if tempMoveChoice[1] == 2
						if (a == 4 && b == 5 && chessboard[srcRow, srcCol].side != chessboard[newTempRow, newTempCol].side && chessboard[newTempRow, newTempCol].side != defDummy)
							tempMoveChoice[a] = newTempRow
							tempMoveChoice[b] = newTempCol
							capture(tempMoveChoice)
						elseif a == 6 && b == 7 && (chessboard[srcRow, srcCol].side != chessboard[tempMoveChoice[4], tempMoveChoice[5]].side && chessboard[tempMoveChoice[4], tempMoveChoice[5]].side != defDummy) || (chessboard[srcRow, srcCol].side != chessboard[newTempRow, newTempCol].side && chessboard[newTempRow, newTempCol].side != defDummy)
							tempMoveChoice[a] = newTempRow
							tempMoveChoice[b] = newTempCol
							capture(tempMoveChoice)
						end
					end
					if tempMoveChoice[1] == 3
						if chessboard[srcRow, srcCol].side != chessboard[tempMoveChoice[a], tempMoveChoice[b]].side && chessboard[tempMoveChoice[a], tempMoveChoice[b]].side != defDummy
							tempMoveChoice[a] = newTempRow
							tempMoveChoice[b] = newTempCol
							capture(tempMoveChoice)
						end
					end
				end
				if (chessboard[srcRow, srcCol].name == defLion || chessboard[srcRow, srcCol].name == defLionHawk) && chessboard[srcRow, srcCol].side != chessboard[newTempRow, newTempCol].side
					stepMultiple(srcRow, srcCol, option, newTempRow, newTempCol, jumps - 1, tempMoveChoice)
				elseif chessboard[newTempRow, newTempCol].side == defDummy
					stepMultiple(srcRow, srcCol, option, newTempRow, newTempCol, jumps - 1, tempMoveChoice)
				end
			end
		end
	end
end

function stepMultipleLinear(srcRow::Int64, srcCol::Int64, option::String, tempRow::Int64, tempCol::Int64, jumps::Int64, index::Int64, tempMoveChoice)
	global tempChessboard
	a = 0
	b = 0
	if jumps == 0
		return
	end
	saveMoveChoice = deepcopy(tempMoveChoice)
	if jumps == 2
		tempMoveChoice = deepcopy(saveMoveChoice)
		newTempRow = tempRow + moveOption[index].row
		newTempCol = tempCol + moveOption[index].col
		if newTempRow <= dim && newTempRow >= 1 && newTempCol <= dim && newTempCol >= 1
			if option == "special update" || option == "demon update" || option == "update"
				update(srcRow, srcCol, newTempRow, newTempCol, option)
			end
			if option == "capture"
				if chessboard[srcRow, srcCol].side != chessboard[newTempRow, newTempCol].side && chessboard[newTempRow, newTempCol].side != defDummy
					tempMoveChoice[4] = newTempRow
					tempMoveChoice[5] = newTempCol			
					capture(tempMoveChoice)
				end
			end
			stepMultipleLinear(srcRow, srcCol, option, newTempRow, newTempCol, jumps - 1, index, tempMoveChoice)
		end
	elseif jumps == 1
		newTempRow = tempRow - moveOption[index].row # igui
		newTempCol = tempCol - moveOption[index].col
			if option == "capture"
				if (chessboard[srcRow, srcCol].side != chessboard[tempMoveChoice[4], tempMoveChoice[5]].side && chessboard[tempMoveChoice[4], tempMoveChoice[5]].side != defDummy) # Check if either has occupied piece.
					tempMoveChoice[6] = newTempRow
					tempMoveChoice[7] = newTempCol
					capture(tempMoveChoice)
				end
			end
		if chessboard[srcRow, srcCol].name != defHeavenlyTetrarch
			newTempRow = tempRow + moveOption[index].row
			newTempCol = tempCol + moveOption[index].col
			if newTempRow <= dim && newTempRow >= 1 && newTempCol <= dim && newTempCol >= 1
				if option == "update"
					update(srcRow, srcCol, newTempRow, newTempCol, option)
				end
				if option == "capture"
					if (chessboard[srcRow, srcCol].side != chessboard[tempMoveChoice[4], tempMoveChoice[5]].side && chessboard[tempMoveChoice[4], tempMoveChoice[5]].side != defDummy) || (chessboard[srcRow, srcCol].side != chessboard[newTempRow, newTempCol].side && chessboard[newTempRow, newTempCol].side != defDummy)
						tempMoveChoice[6] = newTempRow
						tempMoveChoice[7] = newTempCol
						capture(tempMoveChoice)	
					end
				end
			end
		end
	end
end
	
function rangeJump(srcRow::Int64, srcCol::Int64, option::String, index::Int64)
	tempRow = srcRow
	tempCol = srcCol
	while true
		tempRow = tempRow + moveOption[index].row
		tempCol = tempCol + moveOption[index].col
		if tempRow > dim || tempRow < 1 || tempCol > dim || tempCol < 1
			break
		end
		if option == "update" || option == "special update"
			update(srcRow, srcCol, tempRow, tempCol, option)
		end
		if chessboard[srcRow, srcCol].side != chessboard[tempRow, tempCol] && chessboard[tempRow, tempCol].side != defDummy
			if option == "capture"
				tempMoveChoice = [1, srcRow, srcCol, tempRow, tempCol, 0, 0, 0, 0]
				capture(tempMoveChoice)
			end
		end	
		if rangeJumpPriority[chessboard[srcRow, srcCol].name] < rangeJumpPriority[chessboard[tempRow, tempCol].name] # Not jumpable
			break

			break
		end
		if option == "update" || option == "special update" || option == "demon update"
			update(srcRow, srcCol, newTempRow, newTempCol, option)
		end
		if chessboard[newTempRow, newTempCol].side != defDummy
			if option == "capture"
				if chessboard[srcRow, srcCol].side != chessboard[tempRow, tempCol] && chessboard[tempRow, tempCol].side != defDummy
					tempMoveChoice = [1, srcRow, srcCol, tempRow, tempCol, 0, 0, 0, 0]
					capture(tempMoveChoice)
				end
			end
			break
		end
	end
end

function defKingMove(srcRow::Int64, srcCol::Int64, option::String)

	else
		return false
	end
	return false
end

createBoard()
add(7, 8, "vice general", "Bl")
add(8, 8, "pawn", "Bl")
printBoard()
currTurn = "Bl"
moveFunctions("capture")
moveFunctions("update")
strength = -1
printBoardBAttack()