def SetUp(self, options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Steve'
player1Type = 'human'
player1Color = 'white'
player2Name = 'Bob'
player2Type = 'AI'
player2Color = 'black'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color,
player2Type) = GameParams.GetGameSetupParams()
self.player = [0, 0]
if player1Type == 'human':
self.player[0] = ChessPlayer(player1Name, player1Color)
else:
self.player[0] = ChessAI(player1Name, player1Color)
if player2Type == 'human':
self.player[1] = ChessPlayer(player2Name, player2Color)
else:
self.player[1] = ChessAI(player2Name, player2Color)
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if 't' in options:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if 'o' in options:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
def SetUp(self, options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Kasparov'
player1Type = 'human'
player1Color = 'white'
player2Name = 'Light Blue'
player2Type = 'randomAI'
player2Color = 'black'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color,
player2Type) = GameParams.GetGameSetupParams()
self.player = [0, 0]
if player1Type == 'human':
self.player[0] = ChessPlayer(player1Name, player1Color)
elif player1Type == 'randomAI':
self.player[0] = ChessAI_random(player1Name, player1Color)
elif player1Type == 'HeuristicOffense':
self.player[0] = Off_Heuristic(player1Name, player1Color,
self.Board)
elif player1Type == 'EnemyOffense':
self.player[0] = Off_Enemy(player1Name, player1Color, self.Board)
if player2Type == 'human':
self.player[1] = ChessPlayer(player2Name, player2Color)
elif player2Type == 'randomAI':
self.player[1] = ChessAI_random(player2Name, player2Color)
elif player2Type == 'HeuristicDefense':
self.player[1] = Def_Heuristic(player2Name, player2Color,
self.Board)
elif player2Type == 'EnemyDefense':
self.player[1] = Def_Enemy(player2Name, player2Color, self.Board)
if 'AI' in self.player[0].GetType() and 'AI' in self.player[1].GetType(
):
self.AIvsAI = True
else:
self.AIvsAI = False
if options.pauseSeconds > 0:
self.AIpause = True
self.AIpauseSeconds = int(options.pauseSeconds)
else:
self.AIpause = False
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if options.text:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if options.old:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
def SetUp(self, options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Atahualpa'
player1Type = 'humano'
player1Color = 'blanco'
player2Name = 'Huascar'
player2Type = 'randomAI'
player2Color = 'negro'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color,
player2Type) = GameParams.GetGameSetupParams()
self.player = [0, 0]
self.redis = player1Type
if player1Type == 'humano':
self.player[0] = ChessPlayer(player1Name, player1Color)
elif player1Type == 'server':
self.player[0] = ChessPlayer(player1Name, player1Color)
elif player1Type == 'client':
self.player[0] = ChessPlayer(player2Name, player2Color)
elif player1Type == 'offenseAI':
self.player[0] = ChessAI_offense(player1Name, player1Color)
if player2Type == 'humano':
self.player[1] = ChessPlayer(player2Name, player2Color)
elif player2Type == 'server':
self.player[1] = ChessPlayer(player1Name, player1Color)
elif player2Type == 'client':
self.player[1] = ChessPlayer(player2Name, player2Color)
elif player2Type == 'offenseAI':
self.player[1] = ChessAI_offense(player2Name, player2Color)
if options.pauseSeconds > 0:
self.AIpause = True
self.AIpauseSeconds = int(options.pauseSeconds)
else:
self.AIpause = False
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if options.text:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if options.old:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
class PythonChessMain:
def __init__(self, options):
if options.debug:
self.Board = ChessBoard(2)
self.debugMode = True
else:
self.Board = ChessBoard(
6
) #6 for Checkmate with knights setup; see ChessBoard class for other options (for testing purposes)
self.debugMode = False
self.Rules = ChessRules()
def SetUp(self, options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Kasparov'
player1Type = 'human'
player1Color = 'white'
player2Name = 'Light Blue'
player2Type = 'randomAI'
player2Color = 'black'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color,
player2Type) = GameParams.GetGameSetupParams()
self.player = [0, 0]
if player1Type == 'human':
self.player[0] = ChessPlayer(player1Name, player1Color)
elif player1Type == 'randomAI':
self.player[0] = ChessAI_random(player1Name, player1Color)
elif player1Type == 'defenseAI':
self.player[0] = ChessAI_defense(player1Name, player1Color)
elif player1Type == 'offenseAI':
self.player[0] = ChessAI_offense(player1Name, player1Color)
if player2Type == 'human':
self.player[1] = ChessPlayer(player2Name, player2Color)
elif player2Type == 'randomAI':
self.player[1] = ChessAI_random(player2Name, player2Color)
elif player2Type == 'defenseAI':
self.player[1] = ChessAI_defense(player2Name, player2Color)
elif player2Type == 'offenseAI':
self.player[1] = ChessAI_offense(player2Name, player2Color)
if 'AI' in self.player[0].GetType() and 'AI' in self.player[1].GetType(
):
self.AIvsAI = True
else:
self.AIvsAI = False
if options.pauseSeconds > 0:
self.AIpause = True
self.AIpauseSeconds = int(options.pauseSeconds)
else:
self.AIpause = False
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if options.text:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if options.old:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
def MainLoop(self):
currentPlayerIndex = 0
turnCount = 0
while not self.Rules.IsCheckmate(
self.Board.GetState(), self.player[currentPlayerIndex].color):
board = self.Board.GetState()
currentColor = self.player[currentPlayerIndex].GetColor()
#hardcoded so that player 1 is always white
if currentColor == 'white':
turnCount = turnCount + 1
self.Gui.PrintMessage("")
baseMsg = "TURN %s - %s (%s)" % (
str(turnCount), self.player[currentPlayerIndex].GetName(),
currentColor)
self.Gui.PrintMessage("-----%s-----" % baseMsg)
self.Gui.Draw(board)
if self.Rules.IsInCheck(board, currentColor):
self.Gui.PrintMessage(
"Warning..." + self.player[currentPlayerIndex].GetName() +
" (" + self.player[currentPlayerIndex].GetColor() +
") is in check!")
if self.player[currentPlayerIndex].GetType() == 'AI':
moveTuple = self.player[currentPlayerIndex].GetMove(
self.Board.GetState(), currentColor)
else:
moveTuple = self.Gui.GetPlayerInput(board, currentColor)
moveReport = self.Board.MovePiece(
moveTuple
) #moveReport = string like "White Bishop moves from A1 to C3" (+) "and captures ___!"
self.Gui.PrintMessage(moveReport)
currentPlayerIndex = (
currentPlayerIndex + 1
) % 2 #this will cause the currentPlayerIndex to toggle between 1 and 0
if self.AIvsAI and self.AIpause:
time.sleep(self.AIpauseSeconds)
self.Gui.PrintMessage("CHECKMATE!")
winnerIndex = (currentPlayerIndex + 1) % 2
self.Gui.PrintMessage(self.player[winnerIndex].GetName() + " (" +
self.player[winnerIndex].GetColor() +
") won the game!")
self.Gui.EndGame(board)
len(protectedMoveTuples) - 1)]
else:
#If there aren't any protected moves, revert to random AI
#print "No protected move exists; going to random's GetMove"
return ChessAI_random.GetMove(self, board, color)
if __name__ == "__main__":
from ChessBoard import ChessBoard
cb = ChessBoard(3)
board = cb.GetState()
color = 'black'
from ChessGUI_pygame import ChessGUI_pygame
gui = ChessGUI_pygame()
gui.Draw(board, highlightSquares=[])
defense = ChessAI_defense('Bob', 'black')
myPieces = defense.GetMyPiecesWithLegalMoves(board, color)
enemyPieces = defense.GetEnemyPiecesWithLegalMoves(board, color)
protectedMoveTuples = defense.GetProtectedMoveTuples(
board, color, myPieces, enemyPieces)
movesThatPutEnemyInCheck = defense.GetMovesThatPutEnemyInCheck(
board, color, protectedMoveTuples)
print "MyPieces = ", cb.ConvertSquareListToAlgebraicNotation(myPieces)
print "enemyPieces = ", cb.ConvertSquareListToAlgebraicNotation(
enemyPieces)
print "protectedMoveTuples = ", cb.ConvertMoveTupleListToAlgebraicNotation(
protectedMoveTuples)
print "movesThatPutEnemyInCheck = ", cb.ConvertMoveTupleListToAlgebraicNotation(
class PythonChessMain:
def __init__(self, options):
if options.debug:
self.Board = ChessBoard(2)
self.debugMode = True
else:
self.Board = ChessBoard(
0
) #0 for normal board setup; see ChessBoard class for other options (for testing purposes)
self.debugMode = False
self.Rules = ChessRules()
def SetUp(self, options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Kasparov'
player1Type = 'human'
player1Color = 'white'
player2Name = 'Light Blue'
player2Type = 'randomAI'
player2Color = 'black'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color,
player2Type) = GameParams.GetGameSetupParams()
self.player = [0, 0]
if player1Type == 'human':
self.player[0] = ChessPlayer(player1Name, player1Color)
elif player1Type == 'randomAI':
self.player[0] = ChessAI_random(player1Name, player1Color)
elif player1Type == 'HeuristicOffense':
self.player[0] = Off_Heuristic(player1Name, player1Color,
self.Board)
elif player1Type == 'EnemyOffense':
self.player[0] = Off_Enemy(player1Name, player1Color, self.Board)
if player2Type == 'human':
self.player[1] = ChessPlayer(player2Name, player2Color)
elif player2Type == 'randomAI':
self.player[1] = ChessAI_random(player2Name, player2Color)
elif player2Type == 'HeuristicDefense':
self.player[1] = Def_Heuristic(player2Name, player2Color,
self.Board)
elif player2Type == 'EnemyDefense':
self.player[1] = Def_Enemy(player2Name, player2Color, self.Board)
if 'AI' in self.player[0].GetType() and 'AI' in self.player[1].GetType(
):
self.AIvsAI = True
else:
self.AIvsAI = False
if options.pauseSeconds > 0:
self.AIpause = True
self.AIpauseSeconds = int(options.pauseSeconds)
else:
self.AIpause = False
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if options.text:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if options.old:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
def MainLoop(self):
currentPlayerIndex = 0
turnCount = 0
# open("log_X.txt", "w").close()
# open("log_Y.txt", "w").close()
prevBoards = [] #To compare previous boards
while not self.Rules.IsCheckmate(
self.Board.GetState(), self.player[currentPlayerIndex].color):
board = self.Board.GetState()
currentColor = self.player[currentPlayerIndex].GetColor()
#hardcoded so that player 1 is always white
turnCount = turnCount + 1
if turnCount == 101:
self.Gui.PrintMessage("Maximum moves reached.")
self.Gui.EndGame(board)
if currentColor == 'black': #Only the defense player wants a draw
#print prevBoards.count(board)
if prevBoards.count(board) == 2:
self.Gui.PrintMessage(
"Black player calls threefold repetition draw.")
self.Gui.EndGame(board)
prevBoards.append(copy.deepcopy(board))
self.Gui.PrintMessage("")
baseMsg = "TURN %s - %s (%s)" % (
str(turnCount), self.player[currentPlayerIndex].GetName(),
currentColor)
self.Gui.PrintMessage("-----%s-----" % baseMsg)
self.Gui.Draw(board)
if currentColor == "white":
currentPlayer = "X"
if currentColor == "black":
currentPlayer = "Y"
if self.Rules.IsInCheck(board, currentColor):
self.Gui.PrintMessage(
"Warning..." + self.player[currentPlayerIndex].GetName() +
" (" + self.player[currentPlayerIndex].GetColor() +
") is in check!")
move = ""
if self.player[currentPlayerIndex].GetType() == 'HeuristicDefense':
# then get new move to put into MoveTuple and make move
currentPlayer = "Y"
if turnCount > 1:
textFileX = open("log_X.txt", "r")
for line in textFileX:
move = line
textFileY = open("log_Y.txt", "a")
textFileY.write(move)
textFileY.close()
textFileX.close()
moveTuple = self.player[currentPlayerIndex].GetMove(
self.Board.GetState(), currentColor)
self.WriteMove(board, moveTuple, currentPlayer, turnCount)
# write to text file player_ytext below before changing currentPlayerIndex below
elif self.player[currentPlayerIndex].GetType(
) == 'HeuristicOffense':
currentPlayer = "X"
if turnCount > 1:
textFileY = open("log_Y.txt", "r")
for line in textFileY:
move = line
textFileX = open("log_X.txt", "a")
textFileX.write(move)
textFileX.close()
textFileY.close()
moveTuple = self.player[currentPlayerIndex].GetMove(
self.Board.GetState(), currentColor)
self.WriteMove(board, moveTuple, currentPlayer, turnCount)
# # then get new move to put into Movetuple and make move
# # write to text file player_xtext below before changing currentPlayerIndex below
elif self.player[currentPlayerIndex].GetType() == 'EnemyDefense':
moveTuple = self.player[currentPlayerIndex].GetMove(
self.Board.GetState(), currentColor, turnCount)
# #CALL READ FUNCTION HERE FOR ENEMY PLAYER == DEFENSE KRUTIK
# #moveTuple = defense read function
elif self.player[currentPlayerIndex].GetType() == 'EnemyOffense':
moveTuple = self.player[currentPlayerIndex].GetMove(
self.Board.GetState(), currentColor, turnCount)
# #CALL READ FUNCTION HERE FOR ENEMY PLAYER == OFFENSE KRUTIK
# #moveTuple = offense read function
else:
moveTuple = self.Gui.GetPlayerInput(board, currentColor)
moveReport = self.Board.MovePiece(
moveTuple
) #moveReport = string like "White Bishop moves from A1 to C3" (+) "and captures ___!"
self.Gui.PrintMessage(moveReport)
# use current player index to determine what file to write to
# index = 0 is player x / "white" / offense
# index = 1 is player y / "black" / defense
currentPlayerIndex = (
currentPlayerIndex + 1
) % 2 #this will cause the currentPlayerIndex to toggle between 1 and 0
self.AIvsAI = True
if self.AIvsAI and self.AIpause:
time.sleep(self.AIpauseSeconds)
self.Gui.PrintMessage("CHECKMATE!")
winnerIndex = (currentPlayerIndex + 1) % 2
self.Gui.PrintMessage(self.player[winnerIndex].GetName() + " (" +
self.player[winnerIndex].GetColor() +
") won the game!")
self.Gui.EndGame(board)
def WriteMove(self, board, tuple, currentPlayer, turnCount):
#a-g columns
#1-8 rows
pieceRow = tuple[0][0]
pieceCol = tuple[0][1]
pieceToMove = board[pieceRow][pieceCol]
print tuple
if tuple[1][1] == 0:
columnLetter = 'a'
elif tuple[1][1] == 1:
columnLetter = 'b'
elif tuple[1][1] == 2:
columnLetter = 'c'
elif tuple[1][1] == 3:
columnLetter = 'd'
elif tuple[1][1] == 4:
columnLetter = 'e'
elif tuple[1][1] == 5:
columnLetter = 'f'
elif tuple[1][1] == 6:
columnLetter = 'g'
elif tuple[1][1] == 7:
columnLetter = 'h'
if tuple[1][0] == 0:
rowNumber = 8
elif tuple[1][0] == 1:
rowNumber = 7
elif tuple[1][0] == 2:
rowNumber = 6
elif tuple[1][0] == 3:
rowNumber = 5
elif tuple[1][0] == 4:
rowNumber = 4
elif tuple[1][0] == 5:
rowNumber = 3
elif tuple[1][0] == 6:
rowNumber = 2
elif tuple[1][0] == 7:
rowNumber = 1
fileName = "log_" + currentPlayer + ".txt"
file = open(fileName, "a")
file.write(
str(turnCount) + " " + currentPlayer + ":" + pieceToMove[1] + ":" +
columnLetter + str(rowNumber) + "\n")
file.close()
class PythonChessMain:
def __init__(self,options):
if options.debug:
self.Board = ChessBoard(1)
self.debugMode = True
else:
self.Board = ChessBoard(0)#0 for normal board setup; see ChessBoard class for other options (for testing purposes)
self.debugMode = False
self.Rules = ChessRules()
self.StateList = []
def SetUp(self,options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Kasparov'
player1Type = 'human'
player1Color = 'white'
player2Name = 'Light Blue'
player2Type = 'AI'
player2Color = 'black'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color, player2Type) = GameParams.GetGameSetupParams()
self.player = [0,0]
if player1Type == 'human':
self.player[0] = ChessPlayer(player1Name,player1Color)
elif player1Type == 'RandomAI':
self.player[0] = ChessAI_random(player1Name,player1Color)
elif player1Type == 'SunpushAI':
self.player[0] = ChessAI_sunpush(player1Name,player1Color)
if player2Type == 'human':
self.player[1] = ChessPlayer(player2Name,player2Color)
elif player2Type == 'RandomAI':
self.player[1] = ChessAI_random(player2Name,player2Color)
elif player2Type == 'SunpushAI':
self.player[1] = ChessAI_sunpush(player2Name,player2Color)
if 'AI' in self.player[0].GetType() and 'AI' in self.player[1].GetType():
self.AIvsAI = True
else:
self.AIvsAI = False
if options.pauseSeconds > 0:
self.AIpause = True
self.AIpauseSeconds = int(options.pauseSeconds)
else:
self.AIpause = False
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if options.text:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if options.old:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
def MainLoop(self):
currentPlayerIndex = 0
turnCount = 0
movelist=[]
while not self.Rules.IsCheckmate(self.Board) and not self.Rules.IsStalemate(self):
self.Board.GetSquaresLayout()
currentColor = self.player[currentPlayerIndex].GetColor()
self.StateList.append((self.Board.board,currentColor))
#hardcoded so that player 1 is always white
if currentColor == 'white':
turnCount = turnCount + 1
self.Gui.PrintMessage("")
baseMsg = "TURN %s - %s (%s)" % (str(turnCount),self.player[currentPlayerIndex].GetName(),currentColor)
self.Gui.PrintMessage("-----%s-----" % baseMsg)
self.Gui.Draw(self.Board,currentColor)
if self.Rules.IsInCheck(self.Board):
self.Gui.PrintMessage("Warning..."+self.player[currentPlayerIndex].GetName()+" ("+self.player[currentPlayerIndex].GetColor()+") is in check!")
if self.player[currentPlayerIndex].GetType() == 'AI':
moveTuple = self.player[currentPlayerIndex].GetMove(self.Board)
if moveTuple[1] not in self.Rules.GetListOfValidMoves(self.Board,moveTuple[0]):
if (moveTuple[1],moveTuple[2]) not in self.Rules.GetListOfValidMoves(self.Board,moveTuple[0]):
print(moveTuple[1])
print(self.Rules.DoesMovePutPlayerInCheck(self.Board,'white',moveTuple))
raise TypeError('AI did an invalid move')
else:
moveTuple = self.Gui.GetPlayerInput(self.Board,currentColor)
moveReport = self.Board.MovePiece(moveTuple,currentColor,getMessage=True) #moveReport = string like "White Bishop moves from A1 to C3" (+) "and captures ___!"
self.Board.GetSquaresLayout()
movelist.append(moveReport+'\n')
self.Gui.PrintMessage(moveReport)
currentPlayerIndex = (currentPlayerIndex+1)%2 #this will cause the currentPlayerIndex to toggle between 1 and 0
if self.AIvsAI and self.AIpause:
time.sleep(self.AIpauseSeconds)
self.Gui.Draw(self.Board,currentColor)
with open('logs/chess','w') as f:
f.writelines(movelist)
self.Board.Rotate() #rotate it so that chessrules can understand it
#self.Board.GetSquaresLayout()
if self.Rules.IsCheckmate(self.Board):
self.Board.Rotate()
self.Board.GetSquaresLayout()
self.Gui.Draw(self.Board,currentColor)
self.Gui.PrintMessage("CHECKMATE!")
winnerIndex = (currentPlayerIndex+1)%2
self.Gui.PrintMessage(self.player[winnerIndex].GetName()+" ("+self.player[winnerIndex].GetColor()+") won the game!")
else:
self.Board.Rotate()
self.Gui.Draw(self.Board,currentColor)
self.Gui.PrintMessage("STALEMATE!")
self.Gui.PrintMessage("It's a draw!")
self.Gui.EndGame(self.Board,currentColor)
class PythonChessMain:
def __init__(self, options):
if 'd' in options:
self.Board = ChessBoard(2)
self.debugMode = True
else:
self.Board = ChessBoard(
0
) #0 for normal board setup; see ChessBoard class for other options (for testing purposes)
self.debugMode = False
self.Rules = ChessRules()
def SetUp(self, options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Steve'
player1Type = 'human'
player1Color = 'white'
player2Name = 'Bob'
player2Type = 'AI'
player2Color = 'black'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color,
player2Type) = GameParams.GetGameSetupParams()
self.player = [0, 0]
if player1Type == 'human':
self.player[0] = ChessPlayer(player1Name, player1Color)
else:
self.player[0] = ChessAI(player1Name, player1Color)
if player2Type == 'human':
self.player[1] = ChessPlayer(player2Name, player2Color)
else:
self.player[1] = ChessAI(player2Name, player2Color)
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if 't' in options:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if 'o' in options:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
def MainLoop(self):
currentPlayerIndex = 0
turnCount = 0
while not self.Rules.IsCheckmate(
self.Board.GetState(), self.player[currentPlayerIndex].color):
board = self.Board.GetState()
currentColor = self.player[currentPlayerIndex].GetColor()
#hardcoded so that player 1 is always white
if currentColor == 'white':
turnCount = turnCount + 1
self.Gui.Draw(board)
self.Gui.PrintMessage("")
self.Gui.PrintMessage("-----------TURN " + str(turnCount) + " - " +
self.player[currentPlayerIndex].GetName() +
" (" + currentColor + ")-----------")
if self.Rules.IsInCheck(board, currentColor):
self.Gui.PrintMessage(
"Warning..." + self.player[currentPlayerIndex].GetName() +
" (" + self.player[currentPlayerIndex].GetColor() +
") is in check!")
if self.player[currentPlayerIndex].GetType() == 'AI':
moveTuple = self.player[currentPlayerIndex].GetMove(
self.Board.GetState(), currentColor)
else:
moveTuple = self.Gui.GetPlayerInput(board, currentColor)
moveReport = self.Board.MovePiece(
moveTuple
) #moveReport = string like "White Bishop moves from A1 to C3" (+) "and captures ___!"
self.Gui.PrintMessage(moveReport)
currentPlayerIndex = (
currentPlayerIndex + 1
) % 2 #this will cause the currentPlayerIndex to toggle between 1 and 0
self.Gui.PrintMessage("CHECKMATE!")
winnerIndex = (currentPlayerIndex + 1) % 2
self.Gui.PrintMessage(self.player[winnerIndex].GetName() + " (" +
self.player[winnerIndex].GetColor() +
") won the game!")
self.Gui.Draw(board) #draw board a final time to show the end game
c = raw_input(
"Game finished...press any key to quit.") #pause at the end
if self.guitype == 'pygame':
pygame.quit()
class ChessAI_defense(ChessAI_random): #tamame harakate mojaze khodam va harif ro chek mikonam
# kheylee sade harakati ke be ye khune montahi mishano hazf mikonam. @ betarze ahmaqane harakati ke harifo kish mikonan
#ro tarjih midam!! :| dar gheire in soorat ye harakat random az mabaqie harakat bar midaram.
def __init__(self,name,color,protectionPriority=("queen","rook","knight","bishop","pawn")):
self.piecePriority = protectionPriority
ChessAI.__init__(self,name,color)
def GetMove(self,board,color):
myPieces = self.moherehaye_harakatdar(board,color)
harifPieces = self.GetharifPiecesWithharakate_mojaz(board,color)
protectedMoveTuples = self.GetProtectedMoveTuples(board,color,myPieces,harifPieces)
movesThatPutharifInCheck = self.GetMovesThatPutharifInCheck(board,color,protectedMoveTuples)
if len(movesThatPutharifInCheck) > 0:
return movesThatPutharifInCheck[random.randint(0,len(movesThatPutharifInCheck)-1)]
for pieceType in self.piecePriority: #olaviate 2 inja harakatayi entekhab mishe ke az khatare zade shodan nejat mide
piecesProtectedMoves = self.GetMovesThatProtectPiece(board,color,pieceType,protectedMoveTuples)
if len(piecesProtectedMoves) > 0:
return piecesProtectedMoves[random.randint(0,len(piecesProtectedMoves)-1)]
#olaviate 3 - harakati entekhab mishe ke ye mohre az harif begire
for pieceType in self.piecePriority:
capturePieceMoves = self.GetMovesThatCaptureharifPiece(board,color,pieceType,protectedMoveTuples)
if len(capturePieceMoves) > 0:
return capturePieceMoves[random.randint(0,len(capturePieceMoves)-1)]
#age az olaviat haye 1 ta 3 chzi nabud, yeki az protected haro entekahb mikone
if len(protectedMoveTuples) > 0:
return protectedMoveTuples[random.randint(0,len(protectedMoveTuples)-1)]
else: # age protected ham nabud ye random begir!
return ChessAI_random.GetMove(self,board,color)
def GetharifPiecesWithharakate_mojaz(self,board,color):
if color == "black":
myColor = 'b'
harifColor = 'w'
harifColor_full = 'white'
else:
myColor = 'w'
harifColor = 'b'
harifColor_full = 'black'
harifPieces = []
for row in range(8):
for col in range(8):
piece = board[row][col]
if harifColor in piece:
if len(self.Rules.listofvalidmoves(board,harifColor_full,(row,col))) > 0:
harifPieces.append((row,col))
return harifPieces
def GetProtectedMoveTuples(self,board,color,myPieces,harifPieces):
if color == "black":
myColor = 'b'
harifColor = 'w'
harifColor_full = 'white'
else:
myColor = 'w'
harifColor = 'b'
harifColor_full = 'black'
protectedMoveTuples = []
for my_p in myPieces: ## in for ro chek kon shak daram :| :|
my_harakate_mojaz = self.Rules.listofvalidmoves(board,color,my_p)
toBeRemoved = []
for harif_p in harifPieces:
harif_moves = self.Rules.listofvalidmoves(board,harifColor_full,harif_p)
for harif_m in harif_moves:
if harif_m in my_harakate_mojaz:
toBeRemoved.append(harif_m)
for remove_m in toBeRemoved:
if remove_m in my_harakate_mojaz:
my_harakate_mojaz.remove(remove_m)
for my_m in my_harakate_mojaz: #now, "dangerous" moves are removed
protectedMoveTuples.append((my_p,my_m))
return protectedMoveTuples
def GetMovesThatProtectPiece(self,board,color,pieceType,protectedMoveTuples):
piecesProtectedMoves = []
piecePositions = self.PiecePositions(board,color,pieceType)
if len(piecePositions)>0:
for p in piecePositions:
if self.PieceCanBeCaptured(board,color,p):
piecesProtectedMoves.extend(self.GetPiecesMovesFromMoveTupleList(p,protectedMoveTuples))
return piecesProtectedMoves
def GetMovesThatCaptureharifPiece(self,board,color,pieceType,protectedMoveTuples):
if color == "black":
myColor = 'b'
harifColor = 'w'
harifColor_full = 'white'
else:
myColor = 'w'
harifColor = 'b'
harifColor_full = 'black'
capturePieceMoves = []
harifPiecePositions = self.PiecePositions(board,harifColor,pieceType)
if len(harifPiecePositions)>0:
for p in harifPiecePositions:
if self.PieceCanBeCaptured(board,harifColor,p):
capturePieceMoves.extend(self.GetCapturePieceMovesFromMoveTupleList(p,protectedMoveTuples))
return capturePieceMoves
def GetMovesThatPutharifInCheck(self,board,color,protectedMoveTuples): #range harif ro midam besh :))
if color == "black":
myColor = 'b'
harifColor = 'w'
harifColor_full = 'white'
else:
myColor = 'w'
harifColor = 'b'
harifColor_full = 'black'
movesThatPutharifInCheck = []
for mt in protectedMoveTuples:
if self.Rules.chek_Achmaz(board,harifColor_full,mt[0],mt[1]):
movesThatPutharifInCheck.append(mt)
return movesThatPutharifInCheck
def PiecePositions(self,board,color,pieceType):
if color == "black":
myColor = 'b'
else:
myColor = 'w'
if pieceType == "king":
myPieceType = 'K'
elif pieceType == "queen":
myPieceType = 'Q'
elif pieceType == "rook":
myPieceType = 'R'
elif pieceType == "knight":
myPieceType = 'T'
elif pieceType == "bishop":
myPieceType = 'B'
elif pieceType == "pawn":
myPieceType = 'P'
piecePositions = []
for row in range(8):
for col in range(8):
piece = board[row][col]
if myColor in piece and myPieceType in piece:
piecePositions.append((row,col))
return piecePositions
def PieceCanBeCaptured(self,board,color,p):
if color == "black":
myColor = 'b'
harifColor = 'w'
harifColorFull = 'white'
else:
myColor = 'w'
harifColor = 'b'
harifColorFull = 'black'
for row in range(8):
for col in range(8):
piece = board[row][col]
if harifColor in piece:
if self.Rules.Sah_move(board,harifColorFull,(row,col),p):
return True
return False
def GetCapturePieceMovesFromMoveTupleList(self,p,possibleMoveTuples): ##possible hamoon protected ha hastan
moveTuples = []
for m in possibleMoveTuples:
if m[1] == p:
moveTuples.append(m)
return moveTuples
def GetPiecesMovesFromMoveTupleList(self,p,possibleMoveTuples):
moveTuples = []
for m in possibleMoveTuples:
if m[0] == p:
moveTuples.append(m)
return moveTuples
class ChessAI_offense(ChessAI_defense):
def GetMove(self,board,color):
myPieces = self.moherehaye_harakatdar(board,color)
harifPieces = self.GetharifPiecesWithharakate_mojaz(board,color)
#inja AI harakatio tarjih khahad dad ke mana natunam begiram.
protectedMoveTuples = self.GetProtectedMoveTuples(board,color,myPieces,harifPieces)
#olaviat aval hamlei ke be man hamle kone
movesThatPutharifInCheck = self.GetMovesThatPutharifInCheck(board,color,protectedMoveTuples)
if len(movesThatPutharifInCheck) > 0:
#print "Picking move that puts harif in check"
return movesThatPutharifInCheck[random.randint(0,len(movesThatPutharifInCheck)-1)]
#hamlei mikone ke yeki az mohre haye harifo migire
for pieceType in self.piecePriority:
capturePieceMoves = self.GetMovesThatCaptureharifPiece(board,color,pieceType,protectedMoveTuples)
if len(capturePieceMoves) > 0:
return capturePieceMoves[random.randint(0,len(capturePieceMoves)-1)]
#olaviate 3 harakati mkone ke khatar roshu raf kone
for pieceType in self.piecePriority:
piecesProtectedMoves = self.GetMovesThatProtectPiece(board,color,pieceType,protectedMoveTuples)
if len(piecesProtectedMoves) > 0:
return piecesProtectedMoves[random.randint(0,len(piecesProtectedMoves)-1)]
#age az 1ta 3 chizi nadasht yeki az protected ha bar midare dg
if len(protectedMoveTuples) > 0:
return protectedMoveTuples[random.randint(0,len(protectedMoveTuples)-1)]
else:
return ChessAI_random.GetMove(self,board,color)
if __name__ == "__main__":
from ChessBoard import ChessBoard
cb = ChessBoard(3)
board = cb.GetState()
color = 'black'
from ChessGUI_pygame import ChessGUI_pygame
gui = ChessGUI_pygame()
gui.Draw(board,highlightSquares=[])
defense = ChessAI_defense('Bob','black')
myPieces = defense.moherehaye_harakatdar(board,color)
harifPieces = defense.GetharifPiecesWithharakate_mojaz(board,color)
protectedMoveTuples = defense.GetProtectedMoveTuples(board,color,myPieces,harifPieces)
movesThatPutharifInCheck = defense.GetMovesThatPutharifInCheck(board,color,protectedMoveTuples)
print ("MyPieces = ", cb.ConvertSquareListToAlgebraicNotation(myPieces))
print ("harifPieces = ", cb.ConvertSquareListToAlgebraicNotation(harifPieces))
print ("protectedMoveTuples = ", cb.ConvertMoveTupleListToAlgebraicNotation(protectedMoveTuples))
print ("movesThatPutharifInCheck = ", cb.ConvertMoveTupleListToAlgebraicNotation(movesThatPutharifInCheck))
class PythonChessMain:
def __init__(self, options):
if options.debug:
self.Board = ChessBoard(2)
self.debugMode = True
else:
self.Board = ChessBoard(
0
) #0 for normal board setup; see ChessBoard class for other options (for testing purposes)
self.debugMode = False
self.Rules = ChessRules()
def SetUp(self, options):
#gameSetupParams: Player 1 and 2 Name, Color, Human/AI level
if self.debugMode:
player1Name = 'Atahualpa'
player1Type = 'humano'
player1Color = 'blanco'
player2Name = 'Huascar'
player2Type = 'randomAI'
player2Color = 'negro'
else:
GameParams = TkinterGameSetupParams()
(player1Name, player1Color, player1Type, player2Name, player2Color,
player2Type) = GameParams.GetGameSetupParams()
self.player = [0, 0]
self.redis = player1Type
if player1Type == 'humano':
self.player[0] = ChessPlayer(player1Name, player1Color)
elif player1Type == 'server':
self.player[0] = ChessPlayer(player1Name, player1Color)
elif player1Type == 'client':
self.player[0] = ChessPlayer(player2Name, player2Color)
elif player1Type == 'offenseAI':
self.player[0] = ChessAI_offense(player1Name, player1Color)
if player2Type == 'humano':
self.player[1] = ChessPlayer(player2Name, player2Color)
elif player2Type == 'server':
self.player[1] = ChessPlayer(player1Name, player1Color)
elif player2Type == 'client':
self.player[1] = ChessPlayer(player2Name, player2Color)
elif player2Type == 'offenseAI':
self.player[1] = ChessAI_offense(player2Name, player2Color)
if options.pauseSeconds > 0:
self.AIpause = True
self.AIpauseSeconds = int(options.pauseSeconds)
else:
self.AIpause = False
#create the gui object - didn't do earlier because pygame conflicts with any gui manager (Tkinter, WxPython...)
if options.text:
self.guitype = 'text'
self.Gui = ChessGUI_text()
else:
self.guitype = 'pygame'
if options.old:
self.Gui = ChessGUI_pygame(0)
else:
self.Gui = ChessGUI_pygame(1)
"""def reDato(self,s,sc):
print "globales"
global hilo
global datito
print "esperando mensaje"
mensaje = sc.recv(1024)
print "recibido"
datito=mensaje
print "hilito"
hilo = 1
print "brack"""
def MainLoop(self):
hilo = 0
datito = "123"
s = 0
sc = 0
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#s.settimeout(20)
verify = 2
if self.redis == 'server':
verify = 0
serv = ventanaServer()
(direccion) = serv.GetipServer()
if direccion == '0':
pygame.quit()
sys.exit(0)
else:
s.bind((direccion, 9999))
s.listen(1)
s.settimeout(20)
#s.setblocking (0)
print "Esperando conexion..."
sc, adr = s.accept()
#sc.settimeout(20)
#sc.setblocking (0)
elif self.redis == 'client':
verify = 1
clie = ventanaClient()
(direccion1) = clie.GetipClient()
if direccion1 == '0':
pygame.quit()
sys.exit(0)
else:
s.connect((direccion1, 9999))
currentPlayerIndex = 0
turnCount = 0
sinComer = 0
reySoloBlanco = 0
reySoloNegro = 0
reySolo = 0
ayniN = 0
ayniB = 0
while not self.Rules.IsCheckmate(self.Board.GetState(),
self.player[currentPlayerIndex].color,
ayniB, ayniN):
board = self.Board.GetState()
currentColor = self.player[currentPlayerIndex].GetColor()
#hardcoded so that player 1 is always white
if currentColor == 'blanco':
turnCount = turnCount + 1
self.Gui.PrintMessage("")
baseMsg = "TURNO %s - %s (%s)" % (
str(turnCount), self.player[currentPlayerIndex].GetName(),
currentColor)
self.Gui.PrintMessage("-----%s-----" % baseMsg)
self.Gui.Draw(board)
if self.Rules.IsInCheck(board, currentColor):
self.Gui.PrintMessage(
"Peligro..." + self.player[currentPlayerIndex].GetName() +
" (" + self.player[currentPlayerIndex].GetColor() +
") esta en jaque")
jak = jake()
(ka) = jak.aviso()
if currentColor == 'negro' and verify == 0: #self.player[currentPlayerIndex].GetType() == 'server' and turnCount%2!=0: blanco espera movimiento
"""#s.settimeout(20)
#s.setblocking (0)
#hilo=False
print "ejecutando el treaht"
thread.start_new_thread(self.reDato,(s,sc))
hilo=0
print hilo,"bucle infinito"
while (hilo==0):
pass
#hilo=True
print "salio de bucle",hilo
recibido=datito"""
recibido = sc.recv(1024)
if recibido == "empate":
empa = confirmarDerrota()
(empat) = empa.confirmacionEmpate()
if empat == 1:
sc.send("aceptar")
em = empate()
(emp) = em.mostrarEmpate()
self.Gui.EndGame(board)
elif empat == 2:
sc.send("no")
recibido = sc.recv(1024)
elif recibido == "salir":
vi = victoria()
(vic) = vi.mostrarVictoria()
self.Gui.EndGame(board)
else:
numero = int(recibido)
Aa = numero / 1000
AA = numero % 1000
Ee = AA / 100
EE = AA % 100
Ii = EE / 10
II = EE % 10
moveTuple = (Aa, Ee), (Ii, II)
elif currentColor == 'blanco' and verify == 0: #self.player[currentPlayerIndex].GetType() == 'client' and turnCount%2==0: blanco hace su movimiento
moveTuple = self.Gui.GetPlayerInput(board, currentColor,
verify, s, sc, ayniB,
ayniN)
(a, e), (i, o) = moveTuple
A = str(a)
E = str(e)
I = str(i)
O = str(o)
mensaje = A + E + I + O
sc.send(mensaje)
elif currentColor == 'blanco' and verify == 1: #negro espera movimiento
recibido = s.recv(1024)
if recibido == "empate":
empa = confirmarDerrota()
(empat) = empa.confirmacionEmpate()
if empat == 1:
s.send("aceptar")
em = empate()
(emp) = em.mostrarEmpate()
self.Gui.EndGame(board)
elif empat == 2:
s.send("no")
recibido = s.recv(1024)
elif recibido == "salir":
vi = victoria()
(vic) = vi.mostrarVictoria()
self.Gui.EndGame(board)
else:
numero = int(recibido)
Aa = numero / 1000
AA = numero % 1000
Ee = AA / 100
EE = AA % 100
Ii = EE / 10
II = EE % 10
moveTuple = (Aa, Ee), (Ii, II)
elif currentColor == 'negro' and verify == 1: #blanco hace su movimiento
moveTuple = self.Gui.GetPlayerInput(board, currentColor,
verify, s, sc, ayniB,
ayniN)
(a, e), (i, o) = moveTuple
A = str(a)
E = str(e)
I = str(i)
O = str(o)
mensaje = A + E + I + O
s.send(mensaje)
else:
moveTuple = self.Gui.GetPlayerInput(board, currentColor,
verify, s, sc, ayniB,
ayniN)
moveReport, contadorsito, solito, ayni = self.Board.MovePiece(
moveTuple
) #moveReport = string like "White Bishop moves from A1 to C3" (+) "and captures ___!"
self.Gui.PrintMessage(moveReport)
currentPlayerIndex = (
currentPlayerIndex + 1
) % 2 #this will cause the currentPlayerIndex to toggle between 1 and 0
if ayni == 1:
ayniB = ayniB + 1
print ayniB, "y", ayniN
elif ayni == 2:
ayniN = ayniN + 1
print ayniB, "y", ayniN
if contadorsito == 1:
sinComer = sinComer + 1
else:
sinComer = 0
if solito == 1:
reySoloNegro = reySoloNegro + 1
elif solito == 0:
reySoloBlanco = reySoloBlanco + 1
if reySoloBlanco == 14 or reySoloNegro == 14:
reySolo = reySolo + 1
if sinComer == 28 or reySolo == 15:
em = empate()
(emp) = em.mostrarEmpate()
self.Gui.EndGame(board)
s.close()
self.Gui.PrintMessage(
"-------------------------------------------------- JAKE MATE")
winnerIndex = (currentPlayerIndex + 1) % 2
self.Gui.PrintMessage(self.player[winnerIndex].GetName() + " (" +
self.player[winnerIndex].GetColor() +
") gano el juego")
if (self.player[winnerIndex].GetColor() == 'blanco' and verify
== 0) or (self.player[winnerIndex].GetColor() == 'negro'
and verify == 1):
vi = victoria()
(vic) = vi.mostrarVictoria()
elif (self.player[winnerIndex].GetColor() == 'negro' and verify
== 0) or (self.player[winnerIndex].GetColor() == 'blanco'
and verify == 1):
dec = derrota()
(derr) = dec.mostrarDerrota()
else:
vi = victoria()
(vic) = vi.mostrarVictoria()
self.Gui.EndGame(board)
def __init__(self, options):
self.board = chess.Board()
self.Gui = ChessGUI_pygame(1)
self.ai_players = {}
class PythonChessMain:
def __init__(self, options):
self.board = chess.Board()
self.Gui = ChessGUI_pygame(1)
self.ai_players = {}
def SetUp(self):
game_params = TkinterGameSetupParams()
(player1Type, player1Depth, player2Type, player2Depth) = game_params.GetGameSetupParams()
if player1Type == 'AI':
if player1Depth > 0:
self.ai_players[chess.WHITE] = AI(self.board, chess.WHITE, player1Depth)
else:
self.ai_players[chess.WHITE] = RandomAI()
if player2Type == 'AI':
if player2Depth > 0:
self.ai_players[chess.BLACK] = AI(self.board, chess.BLACK, player2Depth)
else:
self.ai_players[chess.BLACK] = RandomAI(self.board)
def MainLoop(self):
while not self.board.is_game_over():
board = self.board
player = "WHITE" if board.turn else "BLACK"
# hardcoded so that player 1 is always white
self.Gui.PrintMessage("")
baseMsg = "TURN %s - %s" % (board.fullmove_number, player)
self.Gui.PrintMessage("-----%s-----" % baseMsg)
self.Gui.Draw(board)
if board.is_check():
self.Gui.PrintMessage("Warning... " + player + " is in check!")
# Get move from player
if board.turn in self.ai_players:
move = self.ai_players[board.turn].GetNextMove()
else:
move = self.Gui.GetPlayerInput(board)
if board.piece_type_at(move.from_square) is chess.PAWN and move.to_square in chess.SquareSet(
chess.BB_RANK_8):
move.promotion = chess.QUEEN
# Indicate if piece was captured
if board.is_capture(move):
if board.is_en_passant(move):
piece_captured = PIECE_NAMES[chess.PAWN]
else:
piece_captured = PIECE_NAMES[board.piece_at(move.to_square).piece_type]
self.Gui.PrintMessage(
PIECE_NAMES[board.piece_at(move.from_square).piece_type] + ' ' +
str(move) + ' ' + piece_captured + ' was captured')
else:
self.Gui.PrintMessage(PIECE_NAMES[board.piece_at(move.from_square).piece_type] + ' '
+ str(move))
board.push(move)
# Check for end game conditions
if board.is_game_over():
self.Gui.PrintMessage('')
winner = 'Black' if board.turn else 'White'
draw_message = 'The game is a draw!'
if board.is_checkmate():
self.Gui.PrintMessage("Checkmate!")
self.Gui.PrintMessage(winner + " won the game!")
elif board.is_stalemate():
self.Gui.PrintMessage("Stalemate!")
self.Gui.PrintMessage(draw_message)
elif board.is_insufficient_material():
self.Gui.PrintMessage("Insufficient Material!")
self.Gui.PrintMessage(draw_message)
elif board.is_fivefold_repetition():
self.Gui.PrintMessage("Fivefold Repetition!")
self.Gui.PrintMessage(draw_message)
elif board.is_seventyfive_moves():
self.Gui.PrintMessage("Seventy Five Move Rule!")
self.Gui.PrintMessage(draw_message)
self.Gui.PrintMessage('Result: ' + board.result())
self.Gui.EndGame(board)